[llvm-commits] [vmkit] r49477 - in /vmkit/trunk/lib/JnJVM: Classpath/ VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Apr 10 04:35:46 PDT 2008
Author: geoffray
Date: Thu Apr 10 06:35:38 2008
New Revision: 49477
URL: http://llvm.org/viewvc/llvm-project?rev=49477&view=rev
Log:
Isolate allocations between different instances of virtual machines
Modified:
vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.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/JavaCache.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaCache.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/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJITInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
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/LockedMap.cpp
vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp
vmkit/trunk/lib/JnJVM/VMCore/Reader.h
vmkit/trunk/lib/JnJVM/VMCore/ServiceDomain.cpp
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp
vmkit/trunk/lib/JnJVM/VMCore/Zip.h
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Thu Apr 10 06:35:38 2008
@@ -70,7 +70,7 @@
Class* cl = (Class*)_cl;
cl->initialiseClass();
- JavaObject* res = cl->doNew();
+ JavaObject* res = cl->doNew(vm);
for (std::vector<Typedef*>::iterator i = meth->signature->args.begin(),
e = meth->signature->args.end(); i != e; ++i, ++index) {
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Thu Apr 10 06:35:38 2008
@@ -130,42 +130,42 @@
} else if (retType == AssessorDesc::dBool) {
uint32 val = 0;
RUN_METH(Int);
- res = (*Classpath::boolClass)();
+ res = (*Classpath::boolClass)(vm);
(*Classpath::boolValue)(res, val);
} else if (retType == AssessorDesc::dByte) {
uint32 val = 0;
RUN_METH(Int);
- res = (*Classpath::byteClass)();
+ res = (*Classpath::byteClass)(vm);
(*Classpath::byteValue)(res, val);
} else if (retType == AssessorDesc::dChar) {
uint32 val = 0;
RUN_METH(Int);
- res = (*Classpath::charClass)();
+ res = (*Classpath::charClass)(vm);
(*Classpath::charValue)(res, val);
} else if (retType == AssessorDesc::dShort) {
uint32 val = 0;
RUN_METH(Int);
- res = (*Classpath::shortClass)();
+ res = (*Classpath::shortClass)(vm);
(*Classpath::shortValue)(res, val);
} else if (retType == AssessorDesc::dInt) {
uint32 val = 0;
RUN_METH(Int);
- res = (*Classpath::intClass)();
+ res = (*Classpath::intClass)(vm);
(*Classpath::intValue)(res, val);
} else if (retType == AssessorDesc::dLong) {
sint64 val = 0;
RUN_METH(Long);
- res = (*Classpath::longClass)();
+ res = (*Classpath::longClass)(vm);
(*Classpath::longValue)(res, val);
} else if (retType == AssessorDesc::dFloat) {
float val = 0;
RUN_METH(Float);
- res = (*Classpath::floatClass)();
+ res = (*Classpath::floatClass)(vm);
(*Classpath::floatValue)(res, val);
} else if (retType == AssessorDesc::dDouble) {
double val = 0;
RUN_METH(Double);
- res = (*Classpath::doubleClass)();
+ res = (*Classpath::doubleClass)(vm);
(*Classpath::doubleValue)(res, val);
} else if (retType == AssessorDesc::dTab || retType == AssessorDesc::dRef) {
JavaObject* val = 0;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Thu Apr 10 06:35:38 2008
@@ -80,9 +80,10 @@
jboolean publicOnly) {
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
+ Jnjvm* vm = JavaThread::get()->isolate;
if (cl->isArray || isInterface(cl->access)) {
- return (jobject)ArrayObject::acons(0, Classpath::constructorArrayClass);
+ return (jobject)ArrayObject::acons(0, Classpath::constructorArrayClass, vm);
} else {
std::vector<JavaMethod*> meths = cl->virtualMethods;
std::vector<JavaMethod*> res;
@@ -93,13 +94,13 @@
}
}
- ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::constructorArrayClass);
+ ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::constructorArrayClass, vm);
sint32 index = 0;
for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
JavaMethod* meth = *i;
// TODO: check parameter types
- JavaObject* tmp = (*Classpath::newConstructor)();
+ JavaObject* tmp = (*Classpath::newConstructor)(vm);
Classpath::initConstructor->invokeIntSpecial(tmp, Cl, meth);
ret->setAt(index, tmp);
}
@@ -120,7 +121,7 @@
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
if (cl->isArray) {
- return (jobject)ArrayObject::acons(0, Classpath::methodArrayClass);
+ return (jobject)ArrayObject::acons(0, Classpath::methodArrayClass, vm);
} else {
std::vector<JavaMethod*> meths = cl->virtualMethods;
std::vector<JavaMethod*> res;
@@ -138,13 +139,13 @@
}
}
- ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::methodArrayClass);
+ ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::methodArrayClass, vm);
sint32 index = 0;
for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
JavaMethod* meth = *i;
// TODO: check parameter types
- JavaObject* tmp = (*Classpath::newMethod)();
+ JavaObject* tmp = (*Classpath::newMethod)(vm);
Classpath::initMethod->invokeIntSpecial(tmp, Cl, vm->UTF8ToStr(meth->name), meth);
ret->setAt(index, tmp);
}
@@ -297,7 +298,7 @@
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
if (cl->isArray) {
- return (jobject)ArrayObject::acons(0, Classpath::fieldArrayClass);
+ return (jobject)ArrayObject::acons(0, Classpath::fieldArrayClass, vm);
} else {
std::vector<JavaField*> fields = cl->virtualFields;
std::vector<JavaField*> res;
@@ -315,13 +316,13 @@
}
}
- ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::fieldArrayClass);
+ ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::fieldArrayClass, vm);
sint32 index = 0;
for (std::vector<JavaField*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
JavaField* field = *i;
// TODO: check parameter types
- JavaObject* tmp = (*Classpath::newField)();
+ JavaObject* tmp = (*Classpath::newField)(vm);
Classpath::initField->invokeIntSpecial(tmp, Cl, vm->UTF8ToStr(field->name), field);
ret->setAt(index, tmp);
}
@@ -338,7 +339,7 @@
Jnjvm* vm = JavaThread::get()->isolate;
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
std::vector<Class*> & interfaces = cl->interfaces;
- ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass);
+ ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass, vm);
sint32 index = 0;
for (std::vector<Class*>::iterator i = interfaces.begin(), e = interfaces.end();
i != e; ++i, ++index) {
@@ -352,7 +353,8 @@
Attribut* attribut = Attribut::lookup(&cl->attributs,
Attribut::innerClassesAttribut);
if (attribut != 0) {
- Reader* reader = attribut->toReader(cl->bytes, attribut);
+ Reader* reader = attribut->toReader(JavaThread::get()->isolate, cl->bytes,
+ attribut);
uint16 nbi = reader->readU2();
for (uint16 i = 0; i < nbi; ++i) {
@@ -403,7 +405,7 @@
Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false);
if (!(cl->innerOuterResolved))
resolveInnerOuterClasses(cl);
- ArrayObject* res = ArrayObject::acons(cl->innerClasses.size(), Classpath::constructorArrayClass);
+ ArrayObject* res = ArrayObject::acons(cl->innerClasses.size(), Classpath::constructorArrayClass, vm);
uint32 index = 0;
for (std::vector<Class*>::iterator i = cl->innerClasses.begin(),
e = cl->innerClasses.end(); i!= e; i++) {
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp Thu Apr 10 06:35:38 2008
@@ -163,31 +163,32 @@
const AssessorDesc* ass = type->funcs;
JavaObject* obj = (JavaObject*)_obj;
llvm::GenericValue gv = (*field)(obj);
+ Jnjvm* vm = JavaThread::get()->isolate;
JavaObject* res = 0;
if (ass == AssessorDesc::dBool) {
- res = (*Classpath::boolClass)();
+ res = (*Classpath::boolClass)(vm);
(*Classpath::boolValue)(res, (uint32)gv.IntVal.getBoolValue());
} else if (ass == AssessorDesc::dByte) {
- res = (*Classpath::byteClass)();
+ res = (*Classpath::byteClass)(vm);
(*Classpath::byteValue)(res, (uint32)gv.IntVal.getSExtValue());
} else if (ass == AssessorDesc::dChar) {
- res = (*Classpath::charClass)();
+ res = (*Classpath::charClass)(vm);
(*Classpath::charValue)(res, (uint32)gv.IntVal.getZExtValue());
} else if (ass == AssessorDesc::dShort) {
- res = (*Classpath::shortClass)();
+ res = (*Classpath::shortClass)(vm);
(*Classpath::shortValue)(res, (uint32)gv.IntVal.getSExtValue());
} else if (ass == AssessorDesc::dInt) {
- res = (*Classpath::intClass)();
+ res = (*Classpath::intClass)(vm);
(*Classpath::intValue)(res, (uint32)gv.IntVal.getSExtValue());
} else if (ass == AssessorDesc::dLong) {
- res = (*Classpath::longClass)();
+ res = (*Classpath::longClass)(vm);
(*Classpath::longValue)(res, (sint64)gv.IntVal.getSExtValue());
} else if (ass == AssessorDesc::dFloat) {
- res = (*Classpath::floatClass)();
+ res = (*Classpath::floatClass)(vm);
(*Classpath::floatValue)(res, gv.FloatVal);
} else if (ass == AssessorDesc::dDouble) {
- res = (*Classpath::doubleClass)();
+ res = (*Classpath::doubleClass)(vm);
(*Classpath::doubleValue)(res, gv.DoubleVal);
} else if (ass == AssessorDesc::dTab || ass == AssessorDesc::dRef) {
res = (JavaObject*)gv.PointerVal;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Thu Apr 10 06:35:38 2008
@@ -46,7 +46,7 @@
sint32 lgPre = vm->prelib->size;
sint32 lgPost = vm->postlib->size;
- UTF8* res = UTF8::acons(lgPre + lgLib + lgPost, JavaArray::ofChar);
+ UTF8* res = UTF8::acons(lgPre + lgLib + lgPost, JavaArray::ofChar, vm);
memmove(res->elements, vm->prelib->elements, lgPre * sizeof(uint16));
memmove(&(res->elements[lgPre]), &(utf8Lib->elements[stLib]), lgLib * sizeof(uint16));
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Thu Apr 10 06:35:38 2008
@@ -41,7 +41,8 @@
return recGetClassContext(stack, size, first + 1, rec);
}
} else {
- return ArrayObject::acons(rec, Classpath::classArrayClass);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ return ArrayObject::acons(rec, Classpath::classArrayClass, vm);
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Thu Apr 10 06:35:38 2008
@@ -86,7 +86,7 @@
JavaObject* javaThread = (JavaObject*)(*ClasspathThread::assocThread)(vmThread).PointerVal;
assert(javaThread);
- JavaThread* th = gc_new(JavaThread)();
+ JavaThread* th = vm_new(JavaThread::get()->isolate, JavaThread)();
th->initialise(javaThread, JavaThread::get()->isolate);
(*ClasspathThread::vmdata)(vmThread, (JavaObject*)th);
int tid = 0;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Thu Apr 10 06:35:38 2008
@@ -43,11 +43,12 @@
#endif
jobject throwable) {
//int** fp = (int**)__builtin_frame_address(0);
+ Jnjvm* vm = JavaThread::get()->isolate;
int** stack = (int**)alloca(sizeof(int*) * 100);
int real_size = backtrace((void**)stack, 100);
- ArrayUInt32* obj = ArrayUInt32::acons(real_size, JavaArray::ofInt);
+ ArrayUInt32* obj = ArrayUInt32::acons(real_size, JavaArray::ofInt, vm);
memcpy(obj->elements, stack, real_size * sizeof(int));
- JavaObject* vmThrowable = (*Classpath::newVMThrowable)();
+ JavaObject* vmThrowable = (*Classpath::newVMThrowable)(vm);
Classpath::initVMThrowable->invokeIntSpecial(vmThrowable);
(*Classpath::vmDataVMThrowable)(vmThrowable, obj);
return (jobject)vmThrowable;
@@ -64,19 +65,21 @@
Attribut::sourceFileAttribut);
if (sourceAtt) {
- Reader* reader = sourceAtt->toReader(cl->bytes, sourceAtt);
+ Reader* reader = sourceAtt->toReader(JavaThread::get()->isolate, cl->bytes,
+ sourceAtt);
uint16 index = reader->readU2();
sourceName = vm->UTF8ToStr(cl->ctpInfo->UTF8At(index));
}
bool native = isNative(meth->access);
- JavaObject* res = (*Classpath::newStackTraceElement)();
+ JavaObject* res = (*Classpath::newStackTraceElement)(vm);
Classpath::initStackTraceElement->invokeIntSpecial(res, sourceName, (uint32)ip, className, methodName, native);
return res;
}
ArrayObject* recGetStackTrace(int** stack, uint32 size, uint32 first, uint32 rec) {
+ Jnjvm* vm = JavaThread::get()->isolate;
if (size != first) {
int *begIp = (int*)Collector::begOf(stack[first]);
JavaMethod* meth = ip_to_meth(begIp);
@@ -88,7 +91,7 @@
return recGetStackTrace(stack, size, first + 1, rec);
}
} else {
- return ArrayObject::acons(rec, JavaArray::ofObject);
+ return ArrayObject::acons(rec, JavaArray::ofObject, vm);
}
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Thu Apr 10 06:35:38 2008
@@ -41,8 +41,9 @@
ClassArray* JavaArray::ofString = 0;
ClassArray* JavaArray::ofObject = 0;
+#ifndef MULTIPLE_VM
#define ACONS(name, elmt, primSize) \
- name *name::acons(sint32 n, ClassArray* atype) { \
+ name *name::acons(sint32 n, ClassArray* atype, Jnjvm* vm) { \
if (n < 0) \
JavaThread::get()->isolate->negativeArraySizeException(n); \
else if (n > JavaArray::MaxArraySize) \
@@ -54,6 +55,21 @@
memset(res->elements, 0, primSize * n); \
return res; \
}
+#else
+#define ACONS(name, elmt, primSize) \
+ name *name::acons(sint32 n, ClassArray* atype, Jnjvm* vm) { \
+ if (n < 0) \
+ JavaThread::get()->isolate->negativeArraySizeException(n); \
+ else if (n > JavaArray::MaxArraySize) \
+ JavaThread::get()->isolate->outOfMemoryError(n); \
+ name* res = (name*) \
+ (Object*) vm->allocateObject(sizeof(name) + n * primSize, name::VT); \
+ res->initialise(atype); \
+ res->size = n; \
+ memset(res->elements, 0, primSize * n); \
+ return res; \
+ }
+#endif
#define AT(name, elmt) \
elmt name::at(sint32 offset) const { \
@@ -88,13 +104,17 @@
#undef ACONS
#undef AT
-ArrayObject *ArrayObject::acons(sint32 n, ClassArray* atype) {
+ArrayObject *ArrayObject::acons(sint32 n, ClassArray* atype, Jnjvm* vm) {
if (n < 0)
JavaThread::get()->isolate->negativeArraySizeException(n);
else if (n > JavaArray::MaxArraySize)
JavaThread::get()->isolate->outOfMemoryError(n);
ArrayObject* res = (ArrayObject*)
+#ifndef MULTIPLE_VM
(Object*) operator new(sizeof(ArrayObject) + n * sizeof(JavaObject*), JavaObject::VT);
+#else
+ (Object*) vm->allocateObject(sizeof(ArrayObject) + n * sizeof(JavaObject*), JavaObject::VT);
+#endif
res->initialise(atype);
res->size = n;
memset(res->elements, 0, sizeof(JavaObject*) * n);
@@ -258,9 +278,10 @@
static JavaArray* multiCallNewIntern(arrayCtor_t ctor, ClassArray* cl,
uint32 len,
- sint32* dims) {
+ sint32* dims,
+ Jnjvm* vm) {
if (len <= 0) JavaThread::get()->isolate->unknownError("Can not happen");
- JavaArray* _res = ctor(dims[0], cl);
+ JavaArray* _res = ctor(dims[0], cl, vm);
if (len > 1) {
ArrayObject* res = (ArrayObject*)_res;
CommonClass* _base = cl->baseClass();
@@ -270,7 +291,8 @@
arrayCtor_t newCtor = func->arrayCtor;
if (dims[0] > 0) {
for (sint32 i = 0; i < dims[0]; ++i) {
- res->setAt(i, multiCallNewIntern(newCtor, base, (len - 1), &dims[1]));
+ res->setAt(i, multiCallNewIntern(newCtor, base, (len - 1), &dims[1],
+ vm));
}
} else {
for (uint32 i = 1; i < len; ++i) {
@@ -292,5 +314,10 @@
for (uint32 i = 0; i < len; ++i){
dims[i] = va_arg(ap, int);
}
- return multiCallNewIntern((arrayCtor_t)ArrayObject::acons, cl, len, dims);
+#ifdef MULTIPLE_VM
+ Jnjvm* vm = va_arg(ap, Jnjvm*);
+#else
+ Jnjvm* vm = 0;
+#endif
+ return multiCallNewIntern((arrayCtor_t)ArrayObject::acons, cl, len, dims, vm);
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Apr 10 06:35:38 2008
@@ -61,7 +61,7 @@
};
-typedef JavaArray* (*arrayCtor_t)(uint32 len, CommonClass* cl);
+typedef JavaArray* (*arrayCtor_t)(uint32 len, CommonClass* cl, Jnjvm* vm);
#define ARRAYCLASS(name, elmt) \
class name : public JavaArray { \
@@ -69,7 +69,7 @@
static VirtualTable* VT; \
static const llvm::Type* llvmType; \
elmt elements[0]; \
- static name *acons(sint32 n, ClassArray* cl); \
+ static name *acons(sint32 n, ClassArray* cl, Jnjvm* vm); \
elmt at(sint32) const; \
void setAt(sint32, elmt); \
virtual void print(mvm::PrintBuffer* buf) const; \
@@ -93,7 +93,7 @@
static VirtualTable* VT;
static const llvm::Type* llvmType;
JavaObject* elements[0];
- static ArrayObject *acons(sint32 n, ClassArray* cl);
+ static ArrayObject *acons(sint32 n, ClassArray* cl, Jnjvm* vm);
JavaObject* at(sint32) const;
void setAt(sint32, JavaObject*);
virtual void print(mvm::PrintBuffer* buf) const;
@@ -106,7 +106,7 @@
uint16 elements[0];
static const llvm::Type* llvmType;
- static UTF8* acons(sint32 n, ClassArray* cl);
+ static UTF8* acons(sint32 n, ClassArray* cl, Jnjvm* vm);
unsigned short int at(sint32) const;
void setAt(sint32, uint16);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Thu Apr 10 06:35:38 2008
@@ -47,17 +47,16 @@
buf->write("Enveloppe<>");
}
-CacheNode* CacheNode::allocate() {
- CacheNode* cache = gc_new(CacheNode)();
- cache->lastCible = 0;
- cache->methPtr = 0;
- cache->next = 0;
- return cache;
+void CacheNode::initialise() {
+ this->lastCible = 0;
+ this->methPtr = 0;
+ this->next = 0;
}
Enveloppe* Enveloppe::allocate(JavaCtpInfo* ctp, uint32 index) {
- Enveloppe* enveloppe = gc_new(Enveloppe)();
- enveloppe->firstCache = CacheNode::allocate();
+ Enveloppe* enveloppe = vm_new(ctp->classDef->isolate, Enveloppe)();
+ enveloppe->firstCache = vm_new(ctp->classDef->isolate, CacheNode)();
+ enveloppe->firstCache->initialise();
enveloppe->firstCache->enveloppe = enveloppe;
enveloppe->cacheLock = mvm::Lock::allocNormal();
enveloppe->ctpInfo = ctp;
@@ -93,8 +92,9 @@
mvm::jit::protectConstants();//->lock();
Value* llvmEnv =
- ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (enveloppe)),
- Enveloppe::llvmType);
+ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
+ uint64_t (enveloppe)),
+ Enveloppe::llvmType);
mvm::jit::unprotectConstants();//->unlock();
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Thu Apr 10 06:35:38 2008
@@ -36,7 +36,7 @@
Enveloppe* enveloppe;
static const llvm::Type* llvmType;
- static CacheNode* allocate();
+ void initialise();
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Apr 10 06:35:38 2008
@@ -57,15 +57,13 @@
buf->write(">");
}
-Attribut* Attribut::derive(const UTF8* name, unsigned int length, const Reader*
- reader) {
+void Attribut::derive(const UTF8* name, unsigned int length,
+ const Reader* reader) {
- Attribut* attr = gc_new(Attribut)();
- attr->start = reader->cursor;
- attr->nbb = length;
- attr->name = name;
+ this->start = reader->cursor;
+ this->nbb = length;
+ this->name = name;
- return attr;
}
// TODO: Optimize
@@ -80,8 +78,8 @@
return 0;
}
-Reader* Attribut::toReader(ArrayUInt8* array, Attribut* attr) {
- return Reader::allocateReader(array, attr->start, attr->nbb);
+Reader* Attribut::toReader(Jnjvm* vm, ArrayUInt8* array, Attribut* attr) {
+ return vm_new(vm, Reader)(array, attr->start, attr->nbb);
}
@@ -217,13 +215,13 @@
llvmType = signature->virtualType;
}
if (!methPtr) {
- JavaJIT* jit = gc_new(JavaJIT)();
- jit->compilingClass = classDef;
- jit->compilingMethod = this;
+ JavaJIT jit;
+ jit.compilingClass = classDef;
+ jit.compilingMethod = this;
if (isNative(access)) {
- methPtr = jit->nativeCompile();
+ methPtr = jit.nativeCompile();
} else {
- methPtr = jit->javaCompile();
+ methPtr = jit.javaCompile();
}
}
// We can compile it, since if we're here, it's for a good reason
@@ -355,18 +353,33 @@
return res;
}
-JavaObject* Class::doNew() {
+#ifndef MULTIPLE_VM
+JavaObject* Class::doNew(Jnjvm* vm) {
JavaObject* res = (JavaObject*)gc::operator new(virtualSize, virtualVT);
memcpy(res, virtualInstance, virtualSize);
return res;
}
// Copy doNew because LLVM wants two different pointers (for simplicity)
-JavaObject* Class::doNewUnknown() {
+JavaObject* Class::doNewUnknown(Jnjvm* vm) {
JavaObject* res = (JavaObject*)gc::operator new(virtualSize, virtualVT);
memcpy(res, virtualInstance, virtualSize);
return res;
}
+#else
+JavaObject* Class::doNew(Jnjvm* vm) {
+ JavaObject* res = (JavaObject*)vm->allocateObject(virtualSize, virtualVT);
+ memcpy(res, virtualInstance, virtualSize);
+ return res;
+}
+
+// Copy doNew because LLVM wants two different pointers (for simplicity)
+JavaObject* Class::doNewUnknown(Jnjvm* vm) {
+ JavaObject* res = (JavaObject*)vm->allocateObject(virtualSize, virtualVT);
+ memcpy(res, virtualInstance, virtualSize);
+ return res;
+}
+#endif
JavaObject* Class::initialiseObject(JavaObject* res) {
memcpy(res, virtualInstance, virtualSize);
@@ -474,7 +487,8 @@
if (!attribut) {
JavaJIT::initField(this, obj);
} else {
- Reader* reader = attribut->toReader(classDef->bytes, attribut);
+ Reader* reader = attribut->toReader(classDef->isolate,
+ classDef->bytes, attribut);
JavaCtpInfo * ctpInfo = classDef->ctpInfo;
uint16 idx = reader->readU2();
if (funcs == AssessorDesc::dLong) {
@@ -525,7 +539,8 @@
cl->staticVT = VT;
#ifndef MULTIPLE_VM
- JavaObject* val = (JavaObject*)gc::operator new(cl->staticSize, cl->staticVT);
+ JavaObject* val = (JavaObject*)cl->isolate->allocateObject(cl->staticSize,
+ cl->staticVT);
val->initialise(cl);
for (std::vector<JavaField*>::iterator i = cl->staticFields.begin(),
e = cl->staticFields.end(); i!= e; ++i) {
@@ -565,7 +580,7 @@
uint64 size = mvm::jit::getTypeSize(cl->virtualType->getContainedType(0));
cl->virtualSize = size;
cl->virtualVT = VT;
- cl->virtualInstance = (JavaObject*)gc::operator new(size, VT);
+ cl->virtualInstance = (JavaObject*)cl->isolate->allocateObject(size, VT);
cl->virtualInstance->initialise(cl);
for (std::vector<JavaField*>::iterator i = cl->virtualFields.begin(),
@@ -607,7 +622,9 @@
}
void Class::createStaticInstance() {
- JavaObject* val = (JavaObject*)gc::operator new(staticSize, staticVT);
+ JavaObject* val =
+ (JavaObject*)JavaThread::get()->isolate->allocateObject(staticSize,
+ staticVT);
val->initialise(this);
for (std::vector<JavaField*>::iterator i = this->staticFields.begin(),
e = this->staticFields.end(); i!= e; ++i) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Thu Apr 10 06:35:38 2008
@@ -56,11 +56,10 @@
unsigned int start;
unsigned int nbb;
- static Attribut* derive(const UTF8* name, unsigned int length,
- const Reader* reader);
+ void derive(const UTF8* name, unsigned int length, const Reader* reader);
static Attribut* lookup(const std::vector<Attribut*> * vec,
const UTF8* key);
- Reader* toReader(ArrayUInt8* array, Attribut* attr);
+ Reader* toReader(Jnjvm *vm, ArrayUInt8* array, Attribut* attr);
static const UTF8* codeAttribut;
static const UTF8* exceptionsAttribut;
@@ -190,13 +189,13 @@
VirtualTable* virtualVT;
uint64 staticSize;
VirtualTable* staticVT;
- JavaObject* doNew();
- JavaObject* doNewUnknown();
+ JavaObject* doNew(Jnjvm* vm);
+ JavaObject* doNewUnknown(Jnjvm* vm);
JavaObject* initialiseObject(JavaObject* obj);
virtual void print(mvm::PrintBuffer *buf) const;
virtual void tracer(size_t sz);
- JavaObject* operator()();
+ JavaObject* operator()(Jnjvm* vm);
#ifndef MULTIPLE_VM
JavaObject* staticInstance() {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Thu Apr 10 06:35:38 2008
@@ -204,7 +204,7 @@
void JavaCtpInfo::read(Jnjvm *vm, Class* cl, Reader* reader) {
uint32 nbCtp = reader->readU2();
- JavaCtpInfo* res = gc_new(JavaCtpInfo)();
+ JavaCtpInfo* res = vm_new(vm, JavaCtpInfo)();
res->ctpRes = (void**)malloc(sizeof(void*)*nbCtp);
res->ctpDef = (sint32*)malloc(sizeof(sint32)*nbCtp);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Thu Apr 10 06:35:38 2008
@@ -57,8 +57,6 @@
INIT(JavaMethod);
INIT(JavaField);
INIT(JavaCtpInfo);
- INIT(Exception);
- INIT(JavaJIT);
INIT(JavaCond);
INIT(LockObj);
INIT(JavaObject);
@@ -204,6 +202,7 @@
}
extern "C" int boot() {
+
struct sigaction sa;
sigaction(SIGINT, 0, &sa);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp Thu Apr 10 06:35:38 2008
@@ -98,11 +98,11 @@
sprintf(temp, "%s:%s", vm->classpath, jarFile);
vm->setClasspath(temp);
- ZipArchive* archive = ZipArchive::singleArchive(jarFile);
+ ZipArchive* archive = ZipArchive::singleArchive(vm, jarFile);
if (archive) {
ZipFile* file = archive->getFile(PATH_MANIFEST);
if (file) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte);
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, vm);
int ok = archive->readFile(res, file);
if (ok) {
char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS);
@@ -296,12 +296,10 @@
}
-ThreadSystem* ThreadSystem::allocateThreadSystem() {
- ThreadSystem* res = gc_new(ThreadSystem)();
- res->nonDaemonThreads = 1;
- res->nonDaemonLock = mvm::Lock::allocNormal();
- res->nonDaemonVar = mvm::Cond::allocCond();
- return res;
+void ThreadSystem::initialise() {
+ nonDaemonThreads = 1;
+ nonDaemonLock = mvm::Lock::allocNormal();
+ nonDaemonVar = mvm::Cond::allocCond();
}
JavaObject* JavaIsolate::loadAppClassLoader() {
@@ -388,7 +386,7 @@
}
}
- ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString);
+ ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString, this);
for (int i = 2; i < argc; ++i) {
args->setAt(i - 2, (JavaObject*)asciizToStr(argv[i]));
}
@@ -409,7 +407,7 @@
extern const char* GNUClasspathLibs;
JavaIsolate* JavaIsolate::allocateIsolate(Jnjvm* callingVM) {
- JavaIsolate *isolate= gc_new(JavaIsolate)();
+ JavaIsolate *isolate= vm_new(callingVM, JavaIsolate)();
isolate->classpath = getenv("CLASSPATH");
if (!(isolate->classpath)) {
@@ -426,7 +424,7 @@
isolate->analyseClasspathEnv(isolate->bootClasspathEnv);
- isolate->functions = FunctionMap::allocate();
+ isolate->functions = vm_new(isolate, FunctionMap)();
isolate->module = new llvm::Module("Isolate JnJVM");
isolate->protectModule = mvm::Lock::allocNormal();
isolate->TheModuleProvider = new JnjvmModuleProvider(isolate->module,
@@ -434,28 +432,32 @@
JavaJIT::initialiseJITIsolateVM(isolate);
- isolate->bootstrapThread = gc_new(JavaThread)();
+ isolate->bootstrapThread = vm_new(isolate, JavaThread)();
isolate->bootstrapThread->initialise(0, isolate);
+ mvm::Thread* th = mvm::Thread::get();
+ isolate->bootstrapThread->GC = th->GC;
JavaThread::threadKey->set(isolate->bootstrapThread);
- isolate->threadSystem = ThreadSystem::allocateThreadSystem();
+ isolate->threadSystem = vm_new(isolate, ThreadSystem)();
+ isolate->threadSystem->initialise();
isolate->name = "isolate";
isolate->appClassLoader = 0;
isolate->jniEnv = &JNI_JNIEnvTable;
isolate->javavmEnv = &JNI_JavaVMTable;
// We copy so that bootstrap utf8 such as "<init>" are unique
- isolate->hashUTF8 = bootstrapVM->hashUTF8->copy();
- isolate->hashStr = StringMap::allocate();
+ isolate->hashUTF8 = vm_new(isolate, UTF8Map)();
+ bootstrapVM->hashUTF8->copy(isolate->hashUTF8);
+ isolate->hashStr = vm_new(isolate, StringMap)();
isolate->bootstrapClasses = callingVM->bootstrapClasses;
- isolate->loadedMethods = MethodMap::allocate();
- isolate->loadedFields = FieldMap::allocate();
- isolate->javaTypes = jnjvm::TypeMap::allocate();
+ isolate->loadedMethods = vm_new(isolate, MethodMap)();
+ isolate->loadedFields = vm_new(isolate, FieldMap)();
+ isolate->javaTypes = vm_new(isolate, TypeMap)();
isolate->globalRefsLock = mvm::Lock::allocNormal();
#ifdef MULTIPLE_VM
- isolate->statics = StaticInstanceMap::allocate();
- isolate->delegatees = DelegateeMap::allocate();
+ isolate->statics = vm_new(isolate, StaticInstanceMap)();
+ isolate->delegatees = vm_new(isolate, DelegateeMap)();
#endif
return isolate;
@@ -479,36 +481,39 @@
isolate->analyseClasspathEnv(isolate->bootClasspathEnv);
- isolate->functions = FunctionMap::allocate();
+ isolate->functions = vm_new(isolate, FunctionMap)();
isolate->protectModule = mvm::Lock::allocNormal();
isolate->module = new llvm::Module("Bootstrap JnJVM");
isolate->TheModuleProvider = new JnjvmModuleProvider(isolate->module,
isolate->functions);
JavaJIT::initialiseJITBootstrapVM(isolate);
- isolate->bootstrapThread = gc_new(JavaThread)();
+ isolate->bootstrapThread = vm_new(isolate, JavaThread)();
isolate->bootstrapThread->initialise(0, isolate);
+ mvm::Thread* th = mvm::Thread::get();
+ isolate->bootstrapThread->GC = th->GC;
JavaThread::threadKey->set(isolate->bootstrapThread);
isolate->name = "bootstrapVM";
isolate->appClassLoader = 0;
- isolate->hashUTF8 = UTF8Map::allocate();
- isolate->hashStr = StringMap::allocate();
- isolate->bootstrapClasses = ClassMap::allocate();
- isolate->loadedMethods = MethodMap::allocate();
- isolate->loadedFields = FieldMap::allocate();
+ isolate->hashUTF8 = vm_new(isolate, UTF8Map)();
+ isolate->hashStr = vm_new(isolate, StringMap)();
+ isolate->bootstrapClasses = vm_new(isolate, ClassMap)();
+ isolate->loadedMethods = vm_new(isolate, MethodMap)();
+ isolate->loadedFields = vm_new(isolate, FieldMap)();
isolate->jniEnv = &JNI_JNIEnvTable;
isolate->javavmEnv = &JNI_JavaVMTable;
isolate->globalRefsLock = mvm::Lock::allocNormal();
- isolate->javaTypes = jnjvm::TypeMap::allocate();
+ isolate->javaTypes = vm_new(isolate, TypeMap)();
#ifdef MULTIPLE_VM
- isolate->statics = StaticInstanceMap::allocate();
- isolate->delegatees = DelegateeMap::allocate();
+ isolate->statics = vm_new(isolate, StaticInstanceMap)();
+ isolate->delegatees = vm_new(isolate, DelegateeMap)();
#endif
#if defined(SERVICE_VM) || !defined(MULTIPLE_VM)
- isolate->threadSystem = ThreadSystem::allocateThreadSystem();
+ isolate->threadSystem = vm_new(this, ThreadSystem)();
+ isolate->threadSystem->initialise();
#endif
return isolate;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h Thu Apr 10 06:35:38 2008
@@ -33,7 +33,7 @@
virtual void print(mvm::PrintBuffer* buf) const;
virtual void tracer(size_t sz);
- static ThreadSystem* allocateThreadSystem();
+ void initialise();
};
class JavaIsolate : public Jnjvm {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Apr 10 06:35:38 2008
@@ -46,14 +46,6 @@
using namespace jnjvm;
using namespace llvm;
-void Exception::print(mvm::PrintBuffer* buf) const {
- buf->write("Exception<>");
-}
-
-void JavaJIT::print(mvm::PrintBuffer* buf) const {
- buf->write("JavaJIT<>");
-}
-
BasicBlock* JavaJIT::createBasicBlock(const char* name) {
return llvm::BasicBlock::Create(name, llvmFunction);
}
@@ -258,7 +250,8 @@
compilingMethod->printString());
}
- Reader* reader = codeAtt->toReader(compilingClass->bytes, codeAtt);
+ Reader* reader = codeAtt->toReader(compilingClass->isolate,
+ compilingClass->bytes, codeAtt);
maxStack = reader->readU2();
maxLocals = reader->readU2();
codeLen = reader->readU4();
@@ -290,7 +283,7 @@
uint32 index = 0;
uint32 count = 0;
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
uint32 max = args.size() - 1;
#else
uint32 max = args.size();
@@ -317,6 +310,20 @@
new StoreInst(*i, objectLocals[index], false, currentBlock);
}
}
+
+#if defined(MULTIPLE_VM)
+#if !defined(SERVICE_VM)
+ isolateLocal = args[args.size() - 1];
+#else
+ if (compilingClass->isolate == Jnjvm::bootstrapVM) {
+ isolateLocal = args[args.size() - 1];
+ } else {
+ ServiceDomain* vm =
+ (ServiceDomain*)(*Classpath::vmdataClassLoader)(compilingClass->classLoader).PointerVal;
+ isolateLocal = new LoadInst(vm->llvmDelegatee(), "", currentBlock);
+ }
+#endif
+#endif
exploreOpcodes(&compilingClass->bytes->elements[start], codeLen);
@@ -351,7 +358,8 @@
compilingMethod->printString());
}
- Reader* reader = codeAtt->toReader(compilingClass->bytes, codeAtt);
+ Reader* reader = codeAtt->toReader(compilingClass->isolate,
+ compilingClass->bytes, codeAtt);
maxStack = reader->readU2();
maxLocals = reader->readU2();
codeLen = reader->readU4();
@@ -403,13 +411,13 @@
uint32 index = 0;
uint32 count = 0;
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
uint32 max = func->arg_size() - 1;
#else
uint32 max = func->arg_size();
#endif
- for (Function::arg_iterator i = func->arg_begin();
- count < max; ++i, ++index, ++count) {
+ Function::arg_iterator i = func->arg_begin();
+ for (;count < max; ++i, ++index, ++count) {
const Type* cur = i->getType();
@@ -430,7 +438,20 @@
new StoreInst(i, objectLocals[index], false, currentBlock);
}
}
-
+
+#if defined(MULTIPLE_VM)
+#if !defined(SERVICE_VM)
+ isolateLocal = i;
+#else
+ if (compilingClass->isolate == Jnjvm::bootstrapVM) {
+ isolateLocal = i;
+ } else {
+ ServiceDomain* vm =
+ (ServiceDomain*)(*Classpath::vmdataClassLoader)(compilingClass->classLoader).PointerVal;
+ isolateLocal = new LoadInst(vm->llvmDelegatee(), "", currentBlock);
+ }
+#endif
+#endif
exploreOpcodes(&compilingClass->bytes->elements[start], codeLen);
@@ -517,6 +538,7 @@
unsigned JavaJIT::readExceptionTable(Reader* reader) {
uint16 nbe = reader->readU2();
+ std::vector<Exception*> exceptions;
unsigned sync = isSynchro(compilingMethod->access) ? 1 : 0;
nbe += sync;
JavaCtpInfo* ctpInfo = compilingClass->ctpInfo;
@@ -571,7 +593,7 @@
}
for (uint16 i = 0; i < nbe - sync; ++i) {
- Exception* ex = gc_new(Exception)();
+ Exception* ex = new Exception();
ex->startpc = reader->readU2();
ex->endpc = reader->readU2();
ex->handlerpc = reader->readU2();
@@ -696,6 +718,11 @@
}
}
+
+ for (std::vector<Exception*>::iterator i = exceptions.begin(),
+ e = exceptions.end(); i!= e; ++i) {
+ delete *i;
+ }
return nbe;
@@ -967,13 +994,13 @@
void JavaJIT::makeArgs(FunctionType::param_iterator it,
uint32 index, std::vector<Value*>& Args, uint32 nb) {
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
nb++;
#endif
Args.reserve(nb + 2);
Value* args[nb];
-#ifdef SERVICE_VM
- args[nb - 1] = mvm::jit::constantPtrNull;
+#ifdef MULTIPLE_VM
+ args[nb - 1] = isolateLocal;
sint32 start = nb - 2;
it--;
#else
@@ -1121,14 +1148,14 @@
Instruction* JavaJIT::invokeInline(JavaMethod* meth,
std::vector<Value*>& args) {
- JavaJIT* jit = gc_new(JavaJIT)();
- jit->compilingClass = meth->classDef;
- jit->compilingMethod = meth;
- jit->unifiedUnreachable = unifiedUnreachable;
- jit->inlineMethods = inlineMethods;
- jit->inlineMethods[meth] = true;
- Instruction* ret = jit->inlineCompile(llvmFunction, currentBlock,
- currentExceptionBlock, args);
+ JavaJIT jit;
+ jit.compilingClass = meth->classDef;
+ jit.compilingMethod = meth;
+ jit.unifiedUnreachable = unifiedUnreachable;
+ jit.inlineMethods = inlineMethods;
+ jit.inlineMethods[meth] = true;
+ Instruction* ret = jit.inlineCompile(llvmFunction, currentBlock,
+ currentExceptionBlock, args);
inlineMethods[meth] = false;
return ret;
}
@@ -1262,11 +1289,19 @@
Value* val = 0;
if (!cl || !cl->isReady()) {
Value* node = getInitializedClass(index);
+#ifndef MULTIPLE_VM
val = invoke(doNewUnknownLLVM, node, "", currentBlock);
+#else
+ val = invoke(doNewUnknownLLVM, node, isolateLocal, "", currentBlock);
+#endif
} else {
Value* load = new LoadInst(cl->llvmVar(compilingClass->isolate->module),
"", currentBlock);
+#ifdef MULTIPLE_VM
+ val = invoke(doNewLLVM, load, isolateLocal, "", currentBlock);
+#else
val = invoke(doNewLLVM, load, "", currentBlock);
+#endif
// give the real type info, escape analysis uses it
new BitCastInst(val, cl->virtualType, "", currentBlock);
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Thu Apr 10 06:35:38 2008
@@ -43,9 +43,8 @@
class Signdef;
class UTF8;
-class Exception : public mvm::Object {
+class Exception {
public:
- static VirtualTable* VT;
uint32 startpc;
uint32 endpc;
uint32 handlerpc;
@@ -56,29 +55,17 @@
llvm::BasicBlock* handler;
llvm::PHINode* exceptionPHI;
llvm::PHINode* handlerPHI;
-
- virtual void print(mvm::PrintBuffer* buf) const;
- virtual void tracer(size_t sz);
};
-class Opinfo : public mvm::Object {
+class Opinfo {
public:
- static VirtualTable* VT;
llvm::BasicBlock* newBlock;
bool reqSuppl;
- llvm::BasicBlock* exceptionBlock;
-
- virtual void print(mvm::PrintBuffer* buf) const {
- buf->write("Opinfo");
- }
- virtual void tracer(size_t sz);
+ llvm::BasicBlock* exceptionBlock;
};
-class JavaJIT : public mvm::Object {
+class JavaJIT {
public:
- static VirtualTable* VT;
- virtual void print(mvm::PrintBuffer* buf) const;
- virtual void tracer(size_t sz);
static void invokeOnceVoid(Jnjvm* vm, JavaObject* loader,
const char* className,
@@ -139,7 +126,6 @@
// exception local
llvm::Value* supplLocal;
unsigned readExceptionTable(Reader* reader);
- std::vector<Exception*> exceptions;
llvm::BasicBlock* endExceptionBlock;
llvm::BasicBlock* currentExceptionBlock;
llvm::BasicBlock* unifiedUnreachable;
@@ -224,6 +210,11 @@
uint16 maxLocals;
uint32 codeLen;
+#ifdef MULTIPLE_VM
+ llvm::Value* isolateLocal;
+#endif
+
+
static const char* OpcodeNames[256];
static VirtualTable* makeVT(Class* cl, bool stat);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITInitialise.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJITInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITInitialise.cpp Thu Apr 10 06:35:38 2008
@@ -169,11 +169,14 @@
{
std::vector<const Type*> args;
args.push_back(mvm::jit::ptrType);
+#ifdef MULTIPLE_VM
+ args.push_back(mvm::jit::ptrType);
+#endif
const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
false);
doNewLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm5Class5doNewEv",
+ "_ZN5jnjvm5Class5doNewEPNS_5JnjvmE",
module);
}
@@ -181,11 +184,76 @@
{
std::vector<const Type*> args;
args.push_back(mvm::jit::ptrType);
+#ifdef MULTIPLE_VM
+ args.push_back(mvm::jit::ptrType);
+#endif
const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
false);
doNewUnknownLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm5Class12doNewUnknownEv",
+ "_ZN5jnjvm5Class12doNewUnknownEPNS_5JnjvmE",
+ module);
+ }
+
+ // Create multiCallNewLLVM
+ {
+ std::vector<const Type*> args;
+ args.push_back(mvm::jit::ptrType);
+ args.push_back(Type::Int32Ty);
+#ifdef MULTIPLE_VM
+ args.push_back(mvm::jit::ptrType);
+#endif
+ const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
+ true);
+
+ multiCallNewLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm9JavaArray12multiCallNewEPNS_10ClassArrayEjz",
+ module);
+ }
+
+
+
+ // Create *AconsLLVM
+ {
+ std::vector<const Type*> args;
+ args.push_back(Type::Int32Ty);
+ args.push_back(mvm::jit::ptrType);
+#ifdef MULTIPLE_VM
+ args.push_back(mvm::jit::ptrType);
+#endif
+ const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
+ false);
+
+ FloatAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm10ArrayFloat5aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ Int8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm10ArraySInt85aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ DoubleAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm11ArrayDouble5aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ Int16AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm11ArraySInt165aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ Int32AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm11ArraySInt325aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ UTF8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm4UTF85aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ LongAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ " _ZN5jnjvm9ArrayLong5aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
+ module);
+
+ ObjectAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
+ "_ZN5jnjvm11ArrayObject5aconsEiPNS_10ClassArrayEPNS_5JnjvmE",
module);
}
@@ -450,61 +518,6 @@
module);
}
- // Create multiCallNewLLVM
- {
- std::vector<const Type*> args;
- args.push_back(mvm::jit::ptrType);
- args.push_back(Type::Int32Ty);
- const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
- true);
-
- multiCallNewLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm9JavaArray12multiCallNewEPNS_10ClassArrayEjz",
- module);
- }
-
-
-
- // Create *AconsLLVM
- {
- std::vector<const Type*> args;
- args.push_back(Type::Int32Ty);
- args.push_back(mvm::jit::ptrType);
- const FunctionType* type = FunctionType::get(JavaObject::llvmType, args,
- false);
-
- FloatAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm10ArrayFloat5aconsEiPNS_10ClassArrayE",
- module);
-
- Int8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm10ArraySInt85aconsEiPNS_10ClassArrayE",
- module);
-
- DoubleAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm11ArrayDouble5aconsEiPNS_10ClassArrayE",
- module);
-
- Int16AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm11ArraySInt165aconsEiPNS_10ClassArrayE",
- module);
-
- Int32AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm11ArraySInt325aconsEiPNS_10ClassArrayE",
- module);
-
- UTF8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm4UTF85aconsEiPNS_10ClassArrayE",
- module);
-
- LongAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm9ArrayLong5aconsEiPNS_10ClassArrayE",
- module);
-
- ObjectAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5jnjvm11ArrayObject5aconsEiPNS_10ClassArrayE",
- module);
- }
{
std::vector<const Type*> args;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Thu Apr 10 06:35:38 2008
@@ -125,6 +125,7 @@
}
void JavaJIT::compileOpcodes(uint8* bytecodes, uint32 codeLength) {
+ wide = false;
uint32 jsrIndex = 0;
for(uint32 i = 0; i < codeLength; ++i) {
@@ -1771,8 +1772,15 @@
llvm::Value* valCl = new LoadInst(cl->llvmVar(vm->module), "", currentBlock);
llvm::Value* arg1 = popAsInt();
-
+#ifdef MULTIPLE_VM
+ std::vector<Value*> args;
+ args.push_back(arg1);
+ args.push_back(valCl);
+ args.push_back(isolateLocal);
+ push(invoke(ctr, args, "", currentBlock), AssessorDesc::dRef);
+#else
push(invoke(ctr, arg1, valCl, "", currentBlock), AssessorDesc::dRef);
+#endif
break;
}
@@ -1792,8 +1800,15 @@
llvm::Value* valCl = new LoadInst(dcl->llvmVar(vm->module), "", currentBlock);
llvm::Value* arg1 = popAsInt();
-
+#ifdef MULTIPLE_VM
+ std::vector<Value*> args;
+ args.push_back(arg1);
+ args.push_back(valCl);
+ args.push_back(isolateLocal);
+ push(invoke(ObjectAconsLLVM, args, "", currentBlock), AssessorDesc::dRef);
+#else
push(invoke(ObjectAconsLLVM, arg1, valCl, "", currentBlock), AssessorDesc::dRef);
+#endif
break;
}
@@ -1922,6 +1937,9 @@
for (sint32 v = 0; v < dim + 2; ++v) {
Args.push_back(args[v]);
}
+#ifdef MULTIPLE_VM
+ Args.push_back(isolateLocal);
+#endif
push(invoke(multiCallNewLLVM, Args, "", currentBlock), AssessorDesc::dRef);
break;
}
@@ -1966,6 +1984,7 @@
}
void JavaJIT::exploreOpcodes(uint8* bytecodes, uint32 codeLength) {
+ wide = false;
for(uint32 i = 0; i < codeLength; ++i) {
PRINT_DEBUG(JNJVM_COMPILE, 1, COLOR_NORMAL, "\t[at %5d] %-5d ", i,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Thu Apr 10 06:35:38 2008
@@ -277,10 +277,10 @@
((float*)((uint64)obj + field->ptrOffset))[0] = val;
}
-JavaObject* Class::operator()() {
+JavaObject* Class::operator()(Jnjvm* vm) {
if (!isReady())
isolate->loadName(name, classLoader, true, true, true);
- return doNew();
+ return doNew(vm);
}
void JavaField::operator()(JavaObject* obj, float val) {
@@ -750,7 +750,7 @@
}
}
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
Args.push_back(mvm::jit::constantPtrNull);
#endif
@@ -792,7 +792,7 @@
Args.push_back(new VAArgInst(ap, (*i)->funcs->llvmType, "", currentBlock));
}
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
Args.push_back(mvm::jit::constantPtrNull);
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Thu Apr 10 06:35:38 2008
@@ -21,7 +21,8 @@
mvm::Lock* JavaObject::globalLock = 0;
JavaCond* JavaCond::allocate() {
- return gc_new(JavaCond)();
+ // JavaCond::allocate must on behalf of the executing thread
+ return vm_new(JavaThread::get()->isolate, JavaCond)();
}
void JavaCond::notify() {
@@ -75,7 +76,7 @@
}
LockObj* LockObj::allocate() {
- LockObj* res = gc_new(LockObj)();
+ LockObj* res = vm_new(JavaThread::get()->isolate, LockObj)();
res->lock = mvm::Lock::allocRecursive();
res->varcond = JavaCond::allocate();
return res;
@@ -99,12 +100,6 @@
buf->write(">");
}
-JavaObject* JavaObject::allocate(CommonClass* cl) {
- JavaObject* res = gc_new(JavaObject)();
- res->classOf = cl;
- return res;
-}
-
static LockObj* myLock(JavaObject* obj) {
verifyNull(obj);
if (obj->lockObj == 0) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Thu Apr 10 06:35:38 2008
@@ -72,7 +72,6 @@
virtual void print(mvm::PrintBuffer* buf) const;
virtual void tracer(size_t sz);
- static JavaObject* allocate(CommonClass* cl);
void aquire();
void unlock();
void waitIntern(struct timeval *info, bool timed);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Apr 10 06:35:38 2008
@@ -98,7 +98,8 @@
if (!rcache) {
JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true);
if (cache->methPtr) {
- rcache = CacheNode::allocate();
+ rcache = vm_new(ctpInfo->classDef->isolate, CacheNode)();
+ rcache->initialise();
rcache->enveloppe = enveloppe;
} else {
rcache = cache;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Thu Apr 10 06:35:38 2008
@@ -17,7 +17,7 @@
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
- JavaString* res = (JavaString*)(*Classpath::newString)();
+ JavaString* res = (JavaString*)(*Classpath::newString)(vm);
// no need to call the function
// Classpath::initString->run(res, utf8, 0, utf8->size, true);
res->value = utf8;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Thu Apr 10 06:35:38 2008
@@ -60,7 +60,7 @@
const char* name, Jnjvm* vm,
const llvm::Type* t,
const char* assocName, arrayCtor_t ctor) {
- AssessorDesc* res = gc_new(AssessorDesc)();
+ AssessorDesc* res = vm_new(vm, AssessorDesc)();
res->doTrace = dt;
res->byteId = bid;
res->nbb = nb;
@@ -474,7 +474,7 @@
llvmArgs.push_back(args->at(i)->funcs->llvmType);
}
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
llvmArgs.push_back(mvm::jit::ptrType); // domain
#endif
@@ -497,7 +497,7 @@
llvmArgs.push_back(args->at(i)->funcs->llvmType);
}
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
llvmArgs.push_back(mvm::jit::ptrType); // domain
#endif
@@ -521,7 +521,7 @@
llvmArgs.push_back(args->at(i)->funcs->llvmType);
}
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
llvmArgs.push_back(mvm::jit::ptrType); // domain
#endif
@@ -574,7 +574,7 @@
typeError(name, 0);
}
- Signdef* res = gc_new(Signdef)();
+ Signdef* res = vm_new(vm, Signdef)();
res->args = buf;
res->ret = vm->constructType(name->extract(vm, pos, pred));
res->isolate = vm;
@@ -618,7 +618,7 @@
if (funcs == AssessorDesc::dParg) {
return Signdef::signDup(name, vm);
} else {
- Typedef* res = gc_new(Typedef)();
+ Typedef* res = vm_new(vm, Typedef)();
res->isolate = vm;
res->keyName = name;
res->funcs = funcs;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Thu Apr 10 06:35:38 2008
@@ -130,7 +130,7 @@
}
void ClasspathThread::createInitialThread(Jnjvm* vm, JavaObject* th) {
- JavaObject* vmth = (*newVMThread)();
+ JavaObject* vmth = (*newVMThread)(vm);
(*th)(name, (JavaObject*)vm->asciizToStr("main"));
(*th)(priority, (uint32)1);
(*th)(daemon, (uint32)0);
@@ -143,7 +143,7 @@
}
void ClasspathThread::mapInitialThread(Jnjvm* vm) {
- JavaObject* th = (*newThread)();
+ JavaObject* th = (*newThread)(vm);
createInitialThread(vm, th);
JavaThread* myth = JavaThread::get();
myth->javaThread = th;
@@ -221,7 +221,7 @@
// Create getCallingClassLoader
{
std::vector<const llvm::Type*> args;
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
args.push_back(mvm::jit::ptrType);
#endif
const llvm::FunctionType* type =
@@ -238,7 +238,7 @@
{
std::vector<const llvm::Type*> args;
args.push_back(JavaObject::llvmType);
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
args.push_back(mvm::jit::ptrType);
#endif
const llvm::FunctionType* type =
@@ -255,7 +255,7 @@
{
std::vector<const llvm::Type*> args;
args.push_back(JavaObject::llvmType);
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
args.push_back(mvm::jit::ptrType);
#endif
const llvm::FunctionType* type =
@@ -281,7 +281,7 @@
JavaMethod* getCallingClass = UPCALL_METHOD(vm, "gnu/classpath/VMStackWalker", "getCallingClass", "()Ljava/lang/Object;", ACC_STATIC);
{
std::vector<const llvm::Type*> args;
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
args.push_back(mvm::jit::ptrType);
#endif
const llvm::FunctionType* type =
@@ -296,7 +296,7 @@
JavaMethod* getCallingClassLoader = UPCALL_METHOD(vm, "gnu/classpath/VMStackWalker", "getCallingClassLoader", "()Ljava/lang/Object;", ACC_STATIC);
{
std::vector<const llvm::Type*> args;
-#ifdef SERVICE_VM
+#ifdef MULTIPLE_VM
args.push_back(mvm::jit::ptrType);
#endif
const llvm::FunctionType* type =
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Apr 10 06:35:38 2008
@@ -142,7 +142,7 @@
Jnjvm* vm = th->isolate;
CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
if (cl->isArray) assert(0 && "implement me");
- JavaObject* res = ((Class*)cl)->doNew();
+ JavaObject* res = ((Class*)cl)->doNew(vm);
JavaMethod* init =
cl->lookupMethod(Jnjvm::initName,
vm->asciizConstructUTF8("(Ljava/lang/String;)V"), 0, 1);
@@ -216,7 +216,7 @@
CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
if (cl->isArray) JavaThread::get()->isolate->unknownError("implement me");
- return (jobject)((Class*)cl)->doNew();
+ return (jobject)((Class*)cl)->doNew(JavaThread::get()->isolate);
END_EXCEPTION
return 0;
@@ -230,7 +230,7 @@
va_start(ap, methodID);
JavaMethod* meth = (JavaMethod*)methodID;
Class* cl = (Class*)NativeUtil::resolvedImplClass(clazz, true);
- JavaObject* res = cl->doNew();
+ JavaObject* res = cl->doNew(JavaThread::get()->isolate);
meth->invokeIntSpecialAP(res, ap);
va_end(ap);
return (jobject)res;
@@ -1630,7 +1630,7 @@
const UTF8* name = base->name;
const UTF8* arrayName = AssessorDesc::constructArrayName(vm, 0, 1, name);
ClassArray* array = vm->constructArray(arrayName, loader);
- ArrayObject* res = ArrayObject::acons(length, array);
+ ArrayObject* res = ArrayObject::acons(length, array, vm);
if (initialElement) {
memset(res->elements, (int)initialElement,
length * sizeof(JavaObject*));
@@ -1663,7 +1663,7 @@
BEGIN_EXCEPTION
ArrayUInt8* res = 0;
- res = ArrayUInt8::acons(len, JavaArray::ofBool);
+ res = ArrayUInt8::acons(len, JavaArray::ofBool, NativeUtil::myVM(env));
return (jbooleanArray)res;
END_EXCEPTION
@@ -1676,7 +1676,7 @@
BEGIN_EXCEPTION
ArraySInt8* res = 0;
- res = ArraySInt8::acons(len, JavaArray::ofByte);
+ res = ArraySInt8::acons(len, JavaArray::ofByte, NativeUtil::myVM(env));
return (jbyteArray) res;
END_EXCEPTION
@@ -1689,7 +1689,7 @@
BEGIN_EXCEPTION
ArrayUInt16* res = 0;
- res = ArrayUInt16::acons(len, JavaArray::ofChar);
+ res = ArrayUInt16::acons(len, JavaArray::ofChar, NativeUtil::myVM(env));
return (jcharArray) res;
END_EXCEPTION
@@ -1702,7 +1702,7 @@
BEGIN_EXCEPTION
ArraySInt16* res = 0;
- res = ArraySInt16::acons(len, JavaArray::ofShort);
+ res = ArraySInt16::acons(len, JavaArray::ofShort, NativeUtil::myVM(env));
return (jshortArray) res;
END_EXCEPTION
@@ -1715,7 +1715,7 @@
BEGIN_EXCEPTION
ArraySInt32* res = 0;
- res = ArraySInt32::acons(len, JavaArray::ofInt);
+ res = ArraySInt32::acons(len, JavaArray::ofInt, NativeUtil::myVM(env));
return (jintArray) res;
END_EXCEPTION
@@ -1728,7 +1728,7 @@
BEGIN_EXCEPTION
ArrayLong* res = 0;
- res = ArrayLong::acons(len, JavaArray::ofLong);
+ res = ArrayLong::acons(len, JavaArray::ofLong, NativeUtil::myVM(env));
return (jlongArray) res;
END_EXCEPTION
@@ -1741,7 +1741,7 @@
BEGIN_EXCEPTION
ArrayFloat* res = 0;
- res = ArrayFloat::acons(len, JavaArray::ofFloat);
+ res = ArrayFloat::acons(len, JavaArray::ofFloat, NativeUtil::myVM(env));
return (jfloatArray) res;
END_EXCEPTION
@@ -1754,7 +1754,7 @@
BEGIN_EXCEPTION
ArrayDouble* res = 0;
- res = ArrayDouble::acons(len, JavaArray::ofDouble);
+ res = ArrayDouble::acons(len, JavaArray::ofDouble, NativeUtil::myVM(env));
return (jdoubleArray) res;
END_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Apr 10 06:35:38 2008
@@ -198,7 +198,8 @@
for (int i = 0; i < nba; i++) {
const UTF8* attName = ctpInfo->UTF8At(reader->readU2());
unsigned int attLen = reader->readU4();
- Attribut* att = Attribut::derive(attName, attLen, reader);
+ Attribut* att = vm_new(this, Attribut);
+ att->derive(attName, attLen, reader);
attr.push_back(att);
reader->seek(attLen, Reader::SeekCur);
}
@@ -245,7 +246,7 @@
PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s::%s\n", printString(),
cl->printString());
- Reader* reader = Reader::allocateReader(cl->bytes);
+ Reader* reader = vm_new(this, Reader)(cl->bytes);
uint32 magic = reader->readU4();
if (magic != Jnjvm::Magic) {
Jnjvm::error(ClassFormatError, "bad magic number %p", magic);
@@ -284,10 +285,10 @@
if (str[strLen - 1] == dirSeparator[0]) {
sprintf(buf, "%s%s.class", str, asciiz);
- res = Reader::openFile(buf);
+ res = Reader::openFile(this, buf);
} else {
sprintf(buf, "%s.class", asciiz);
- res = Reader::openZip(str, buf);
+ res = Reader::openZip(this, str, buf);
}
idx++;
}
@@ -444,7 +445,7 @@
Class* cl = (Class*) this->loadName(this->asciizConstructUTF8(className),
CommonClass::jnjvmClassLoader,
true, true, true);
- JavaObject* obj = (*cl)();
+ JavaObject* obj = (*cl)(this);
JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
"(Ljava/lang/Throwable;)V", ACC_VIRTUAL, obj, excp);
JavaThread::throwException(obj);
@@ -460,7 +461,7 @@
vsnprintf(tmp, 4096, fmt, ap);
va_end(ap);
- JavaObject* obj = (*cl)();
+ JavaObject* obj = (*cl)(this);
JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
"(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
this->asciizToStr(tmp));
@@ -475,7 +476,7 @@
true, true, true);
vsnprintf(tmp, 4096, fmt, ap);
va_end(ap);
- JavaObject* obj = (*cl)();
+ JavaObject* obj = (*cl)(this);
JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
"(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
this->asciizToStr(tmp));
@@ -632,7 +633,7 @@
ClassMap* map =
(ClassMap*)(*Classpath::vmdataClassLoader)(loader).PointerVal;
if (!map) {
- map = ClassMap::allocate();
+ map = vm_new(this, ClassMap)();
(*Classpath::vmdataClassLoader)(loader, (JavaObject*)map);
}
#else
@@ -652,7 +653,7 @@
}
static CommonClass* arrayDup(const UTF8*& name, Jnjvm *vm) {
- ClassArray* cl = gc_new(ClassArray)();
+ ClassArray* cl = vm_new(vm, ClassArray)();
cl->initialise(vm, true);
cl->name = name;
cl->classLoader = 0;
@@ -681,7 +682,7 @@
ClassMap* map =
(ClassMap*)(*Classpath::vmdataClassLoader)(loader).PointerVal;
if (!map) {
- map = ClassMap::allocate();
+ map = vm_new(this, ClassMap)();
(*Classpath::vmdataClassLoader)(loader, (JavaObject*)map);
}
ClassArray* res = (ClassArray*)map->lookupOrCreate(name, this, arrayDup);
@@ -705,7 +706,7 @@
static CommonClass* classDup(const UTF8*& name, Jnjvm *vm) {
- Class* cl = gc_new(Class)();
+ Class* cl = vm_new(vm, Class)();
cl->initialise(vm, false);
cl->name = name;
cl->classLoader = 0;
@@ -723,7 +724,7 @@
ClassMap* map =
(ClassMap*)(*Classpath::vmdataClassLoader)(loader).PointerVal;
if (!map) {
- map = ClassMap::allocate();
+ map = vm_new(this, ClassMap)();
(*Classpath::vmdataClassLoader)(loader, (JavaObject*)map);
}
Class* res = (Class*)map->lookupOrCreate(name, this, classDup);
@@ -746,7 +747,7 @@
}
static JavaField* fieldDup(FieldCmp & cmp, Jnjvm *vm) {
- JavaField* field = gc_new(JavaField)();
+ JavaField* field = vm_new(vm, JavaField)();
field->name = cmp.name;
field->type = cmp.type;
field->classDef = (Class*)cmp.classDef;
@@ -772,7 +773,7 @@
}
static JavaMethod* methodDup(FieldCmp & cmp, Jnjvm *vm) {
- JavaMethod* method = gc_new(JavaMethod)();
+ JavaMethod* method = vm_new(vm, JavaMethod)();
method->name = cmp.name;
method->type = cmp.type;
method->classDef = (Class*)cmp.classDef;
@@ -791,11 +792,11 @@
}
const UTF8* Jnjvm::asciizConstructUTF8(const char* asciiz) {
- return hashUTF8->lookupOrCreateAsciiz(asciiz);
+ return hashUTF8->lookupOrCreateAsciiz(this, asciiz);
}
const UTF8* Jnjvm::readerConstructUTF8(const uint16* buf, uint32 size) {
- return hashUTF8->lookupOrCreateReader(buf, size);
+ return hashUTF8->lookupOrCreateReader(this, buf, size);
}
Typedef* Jnjvm::constructType(const UTF8* name) {
@@ -835,12 +836,12 @@
#ifndef MULTIPLE_VM
JavaObject* Jnjvm::getClassDelegatee(CommonClass* cl) {
if (!(cl->delegatee)) {
- JavaObject* delegatee = (*Classpath::newClass)();
+ JavaObject* delegatee = (*Classpath::newClass)(this);
cl->delegatee = delegatee;
Classpath::initClass->invokeIntSpecial(delegatee, cl);
} else if (cl->delegatee->classOf != Classpath::newClass) {
JavaObject* pd = cl->delegatee;
- JavaObject* delegatee = (*Classpath::newClass)();
+ JavaObject* delegatee = (*Classpath::newClass)(this);
cl->delegatee = delegatee;;
Classpath::initClassWithProtectionDomain->invokeIntSpecial(delegatee, cl,
pd);
@@ -851,12 +852,12 @@
JavaObject* Jnjvm::getClassDelegatee(CommonClass* cl) {
JavaObject* val = delegatees->lookup(cl);
if (!val) {
- val = (*Classpath::newClass)();
+ val = (*Classpath::newClass)(this);
delegatees->hash(cl, val);
Classpath::initClass->invokeIntSpecial(val, cl);
} else if (val->classOf != Classpath::newClass) {
JavaObject* pd = val;
- val = (*Classpath::newClass)();
+ val = (*Classpath::newClass)(this);
delegatees->hash(cl, val);
Classpath::initClassWithProtectionDomain->invokeIntSpecial(val, cl, pd);
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Apr 10 06:35:38 2008
@@ -22,6 +22,8 @@
#include "types.h"
+#define vm_new(vm, cl) gc_new(cl)
+
namespace jnjvm {
class ArrayUInt8;
@@ -251,6 +253,16 @@
llvm::Module* module;
JnjvmModuleProvider* TheModuleProvider;
FunctionMap* functions;
+
+#ifndef MULTIPLE_VM
+ void* allocateObject(unsigned int sz, VirtualTable* VT) {
+ return gc::operator new(sz, VT);
+ }
+#else
+ void* allocateObject(unsigned int sz, VirtualTable* VT) {
+ return gc::operator new(sz, VT);
+ }
+#endif
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp Thu Apr 10 06:35:38 2008
@@ -74,7 +74,7 @@
}
-const UTF8* UTF8Map::lookupOrCreateAsciiz(const char* asciiz) {
+const UTF8* UTF8Map::lookupOrCreateAsciiz(Jnjvm* vm, const char* asciiz) {
sint32 size = strlen(asciiz);
uint32 key = asciizHasher(asciiz, size);
const UTF8* res = 0;
@@ -90,7 +90,7 @@
}
if (res == 0) {
- UTF8* tmp = UTF8::acons(size, JavaArray::ofChar);
+ UTF8* tmp = UTF8::acons(size, JavaArray::ofChar, vm);
for (sint32 i = 0; i < size; i++) {
tmp->setAt(i, asciiz[i]);
}
@@ -102,7 +102,8 @@
return res;
}
-const UTF8* UTF8Map::lookupOrCreateReader(const uint16* buf, uint32 len) {
+const UTF8* UTF8Map::lookupOrCreateReader(Jnjvm* vm, const uint16* buf,
+ uint32 len) {
sint32 size = (sint32)len;
uint32 key = readerHasher(buf, size);
const UTF8* res = 0;
@@ -118,7 +119,7 @@
}
if (res == 0) {
- UTF8* tmp = UTF8::acons(size, JavaArray::ofChar);
+ UTF8* tmp = UTF8::acons(size, JavaArray::ofChar, vm);
memcpy(tmp->elements, buf, len * sizeof(uint16));
res = (const UTF8*)tmp;
map.insert(std::make_pair(key, res));
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Thu Apr 10 06:35:38 2008
@@ -101,8 +101,8 @@
mvm::Lock* lock;
std::multimap<uint32, const UTF8*> map;
static VirtualTable* VT;
- const UTF8* lookupOrCreateAsciiz(const char* asciiz);
- const UTF8* lookupOrCreateReader(const uint16* buf, uint32 size);
+ const UTF8* lookupOrCreateAsciiz(Jnjvm* vm, const char* asciiz);
+ const UTF8* lookupOrCreateReader(Jnjvm* vm, const uint16* buf, uint32 size);
const UTF8* lookupAsciiz(const char* asciiz);
const UTF8* lookupReader(const uint16* buf, uint32 size);
@@ -117,18 +117,14 @@
buf->write("UTF8 Hashtable<>");
}
- static UTF8Map* allocate() {
- UTF8Map* map = gc_new(UTF8Map)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+ UTF8Map() {
+ lock = mvm::Lock::allocNormal();
}
- UTF8Map* copy() {
- UTF8Map* newMap = allocate();
+ void copy(UTF8Map* newMap) {
for (iterator i = map.begin(), e = map.end(); i!= e; ++i) {
newMap->map.insert(*i);
}
- return newMap;
}
void replace(const UTF8* oldUTF8, const UTF8* newUTF8);
@@ -157,10 +153,9 @@
public LockedMap<const UTF8*, CommonClass*, ltutf8 > {
public:
static VirtualTable* VT;
- static ClassMap* allocate() {
- ClassMap* map = gc_new(ClassMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ ClassMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -175,10 +170,9 @@
public LockedMap<FieldCmp, JavaField*, std::less<FieldCmp> > {
public:
static VirtualTable* VT;
- static FieldMap* allocate() {
- FieldMap* map = gc_new(FieldMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ FieldMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -193,10 +187,9 @@
public LockedMap<FieldCmp, JavaMethod*, std::less<FieldCmp> > {
public:
static VirtualTable* VT;
- static MethodMap* allocate() {
- MethodMap* map = gc_new(MethodMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ MethodMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -219,10 +212,9 @@
class ZipFileMap : public LockedMap<const char*, ZipFile*, ltstr> {
public:
static VirtualTable* VT;
- static ZipFileMap* allocate() {
- ZipFileMap* map = gc_new(ZipFileMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ ZipFileMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -237,10 +229,9 @@
public LockedMap<const UTF8*, JavaString*, ltutf8 > {
public:
static VirtualTable* VT;
- static StringMap* allocate() {
- StringMap* map = gc_new(StringMap)();
- map->lock = mvm::Lock::allocRecursive();
- return map;
+
+ StringMap() {
+ lock = mvm::Lock::allocRecursive();
}
virtual void tracer(size_t sz) {
@@ -255,10 +246,9 @@
public LockedMap<llvm::Function*, std::pair<Class*, uint32>*, std::less<llvm::Function*> > {
public:
static VirtualTable* VT;
- static FunctionMap* allocate() {
- FunctionMap* map = gc_new(FunctionMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ FunctionMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -273,10 +263,9 @@
public LockedMap<llvm::Function*, JavaMethod*, std::less<llvm::Function*> > {
public:
static VirtualTable* VT;
- static FunctionDefMap* allocate() {
- FunctionDefMap* map = gc_new(FunctionDefMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+
+ FunctionDefMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -297,10 +286,8 @@
return 0;
}
- static TypeMap* allocate() {
- TypeMap* map = gc_new(TypeMap)();
- map->lock = mvm::Lock::allocRecursive();
- return map;
+ TypeMap() {
+ lock = mvm::Lock::allocRecursive();
}
virtual void tracer(size_t sz) {
@@ -317,10 +304,8 @@
public:
static VirtualTable* VT;
- static StaticInstanceMap* allocate() {
- StaticInstanceMap* map = gc_new(StaticInstanceMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+ StaticInstanceMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
@@ -343,10 +328,8 @@
public:
static VirtualTable* VT;
- static DelegateeMap* allocate() {
- DelegateeMap* map = gc_new(DelegateeMap)();
- map->lock = mvm::Lock::allocNormal();
- return map;
+ DelegateeMap() {
+ lock = mvm::Lock::allocNormal();
}
virtual void tracer(size_t sz) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Apr 10 06:35:38 2008
@@ -445,7 +445,8 @@
ArrayObject* NativeUtil::getParameterTypes(JavaObject* loader, JavaMethod* meth) {
std::vector<Typedef*>& args = meth->signature->args;
- ArrayObject* res = ArrayObject::acons(args.size(), Classpath::classArrayClass);
+ ArrayObject* res = ArrayObject::acons(args.size(), Classpath::classArrayClass,
+ JavaThread::get()->isolate);
sint32 index = 0;
for (std::vector<Typedef*>::iterator i = args.begin(), e = args.end();
@@ -461,13 +462,16 @@
Attribut* exceptionAtt = Attribut::lookup(&meth->attributs,
Attribut::exceptionsAttribut);
if (exceptionAtt == 0) {
- return ArrayObject::acons(0, Classpath::classArrayClass);
+ return ArrayObject::acons(0, Classpath::classArrayClass,
+ JavaThread::get()->isolate);
} else {
Class* cl = meth->classDef;
JavaCtpInfo* ctp = cl->ctpInfo;
- Reader* reader = exceptionAtt->toReader(cl->bytes, exceptionAtt);
+ Reader* reader = exceptionAtt->toReader(JavaThread::get()->isolate,
+ cl->bytes, exceptionAtt);
uint16 nbe = reader->readU2();
- ArrayObject* res = ArrayObject::acons(nbe, Classpath::classArrayClass);
+ ArrayObject* res = ArrayObject::acons(nbe, Classpath::classArrayClass,
+ JavaThread::get()->isolate);
for (uint16 i = 0; i < nbe; ++i) {
uint16 idx = reader->readU2();
Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Thu Apr 10 06:35:38 2008
@@ -52,27 +52,27 @@
const int Reader::SeekCur = SEEK_CUR;
const int Reader::SeekEnd = SEEK_END;
-ArrayUInt8* Reader::openFile(char* path) {
+ArrayUInt8* Reader::openFile(Jnjvm* vm, char* path) {
FILE* fp = fopen(path, "r");
ArrayUInt8* res = 0;
if (fp != 0) {
fseek(fp, 0, SeekEnd);
long nbb = ftell(fp);
fseek(fp, 0, SeekSet);
- res = ArrayUInt8::acons(nbb, JavaArray::ofByte);
+ res = ArrayUInt8::acons(nbb, JavaArray::ofByte, vm);
fread(res->elements, nbb, 1, fp);
fclose(fp);
}
return res;
}
-ArrayUInt8* Reader::openZip(char* zipname, char* filename) {
- ZipArchive* archive = ZipArchive::hashedArchive(zipname);
+ArrayUInt8* Reader::openZip(Jnjvm* vm, char* zipname, char* filename) {
+ ZipArchive* archive = ZipArchive::hashedArchive(vm, zipname);
ArrayUInt8* ret = 0;
if (archive != 0) {
ZipFile* file = archive->getFile(filename);
if (file != 0) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte);
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, vm);
if (archive->readFile(res, file) != 0) {
ret = res;
}
@@ -119,24 +119,20 @@
return tmp | ((sint64)(readS8()));
}
-Reader* Reader::allocateReader(ArrayUInt8* array, uint32 start,
- uint32 end) {
- Reader* reader = gc_new(Reader)();
+Reader::Reader(ArrayUInt8* array, uint32 start, uint32 end) {
if (!end) end = array->size;
- reader->bytes = array;
- reader->cursor = start;
- reader->min = start;
- reader->max = start + end;
- return reader;
-
+ this->bytes = array;
+ this->cursor = start;
+ this->min = start;
+ this->max = start + end;
}
unsigned int Reader::tell() {
return cursor - min;
}
-Reader* Reader::derive(uint32 nbb) {
- return allocateReader(bytes, cursor, nbb);
+Reader* Reader::derive(Jnjvm* vm, uint32 nbb) {
+ return vm_new(vm, Reader)(bytes, cursor, nbb);
}
void Reader::seek(uint32 pos, int from) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Reader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Reader.h Thu Apr 10 06:35:38 2008
@@ -17,6 +17,7 @@
namespace jnjvm {
class ArrayUInt8;
+class Jnjvm;
class Reader : public mvm::Object {
public:
@@ -33,8 +34,8 @@
static const int SeekCur;
static const int SeekEnd;
- static ArrayUInt8* openFile(char* path);
- static ArrayUInt8* openZip(char* zipname, char* filename);
+ static ArrayUInt8* openFile(Jnjvm* vm, char* path);
+ static ArrayUInt8* openZip(Jnjvm* vm, char* zipname, char* filename);
uint8 readU1();
sint8 readS1();
uint16 readU2();
@@ -43,10 +44,10 @@
sint32 readS4();
uint64 readU8();
sint64 readS8();
- static Reader* allocateReader(ArrayUInt8* array, uint32 start = 0,
- uint32 end = 0);
+ Reader(ArrayUInt8* array, uint32 start = 0, uint32 end = 0);
+ Reader() {}
unsigned int tell();
- Reader* derive(uint32 nbb);
+ Reader* derive(Jnjvm* vm, uint32 nbb);
void seek(uint32 pos, int from);
virtual void print(mvm::PrintBuffer* buf) const;
Modified: vmkit/trunk/lib/JnJVM/VMCore/ServiceDomain.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/ServiceDomain.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/ServiceDomain.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/ServiceDomain.cpp Thu Apr 10 06:35:38 2008
@@ -32,9 +32,9 @@
}
ServiceDomain* ServiceDomain::allocateService(Jnjvm* callingVM) {
- ServiceDomain* service = gc_new(ServiceDomain)();
+ ServiceDomain* service = vm_new(callingVM, ServiceDomain)();
- service->functions = FunctionMap::allocate();
+ service->functions = vm_new(service, FunctionMap)();
service->module = new llvm::Module("Service Domain");
service->protectModule = mvm::Lock::allocNormal();
service->TheModuleProvider = new JnjvmModuleProvider(service->module,
@@ -46,21 +46,22 @@
service->javavmEnv = &JNI_JavaVMTable;
// We copy so that bootstrap utf8 such as "<init>" are unique
- service->hashUTF8 = callingVM->hashUTF8->copy();
- service->hashStr = StringMap::allocate();
+ service->hashUTF8 = vm_new(service, UTF8Map)();
+ callingVM->hashUTF8->copy(service->hashUTF8);
+ service->hashStr = vm_new(service, StringMap)();
service->bootstrapClasses = callingVM->bootstrapClasses;
- service->loadedMethods = MethodMap::allocate();
- service->loadedFields = FieldMap::allocate();
- service->javaTypes = jnjvm::TypeMap::allocate();
+ service->loadedMethods = vm_new(service, MethodMap)();
+ service->loadedFields = vm_new(service, FieldMap)();
+ service->javaTypes = vm_new(service, TypeMap)();
service->globalRefsLock = mvm::Lock::allocNormal();
#ifdef MULTIPLE_VM
- service->statics = StaticInstanceMap::allocate();
- service->delegatees = DelegateeMap::allocate();
+ service->statics = vm_new(service, StaticInstanceMap)();
+ service->delegatees = vm_new(service, DelegateeMap)();
#endif
// A service is related to a class loader
// Here are the classes it loaded
- service->classes = ClassMap::allocate();
+ service->classes = vm_new(service, ClassMap)();
service->started = 0;
service->executionTime = 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Apr 10 06:35:38 2008
@@ -14,7 +14,6 @@
#include "JavaClass.h"
#include "JavaConstantPool.h"
#include "JavaIsolate.h"
-#include "JavaJIT.h"
#include "JavaObject.h"
#include "JavaString.h"
#include "JavaThread.h"
@@ -50,8 +49,6 @@
INIT(JavaMethod);
INIT(JavaField);
INIT(JavaCtpInfo);
- INIT(Exception);
- INIT(JavaJIT);
INIT(JavaCond);
INIT(LockObj);
INIT(JavaObject);
@@ -76,7 +73,6 @@
INIT(FunctionDefMap);
INIT(JavaIsolate);
INIT(JavaString);
- INIT(Opinfo);
INIT(CacheNode);
INIT(Enveloppe);
INIT(DelegateeMap);
@@ -189,21 +185,6 @@
// do not trace them here
}
-void Exception::tracer(size_t sz) {
- catchClass->markAndTrace();
-}
-
-void Opinfo::tracer(size_t sz) {
-}
-
-void JavaJIT::tracer(size_t sz) {
- compilingClass->markAndTrace();
- compilingMethod->markAndTrace();
- TRACE_VECTOR(Exception*, exceptions);
-
- // Do not trace opinfos: they are allocated in stack
-}
-
void JavaCond::tracer(size_t sz) {
TRACE_VECTOR(JavaThread*, threads);
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp Thu Apr 10 06:35:38 2008
@@ -10,26 +10,28 @@
#include <zlib.h>
#include "JavaArray.h"
+#include "Jnjvm.h"
#include "LockedMap.h"
#include "Reader.h"
#include "Zip.h"
using namespace jnjvm;
-ZipArchive* ZipArchive::hashedArchive(char* archname) {
+ZipArchive* ZipArchive::hashedArchive(Jnjvm* vm, char* archname) {
assert(0 && "implement hashedArchive");
return 0;
}
-ZipArchive* ZipArchive::singleArchive(char* archname) {
- ZipArchive* ar = gc_new(ZipArchive)();
+ZipArchive* ZipArchive::singleArchive(Jnjvm* vm, char* archname) {
+ ZipArchive* ar = vm_new(vm, ZipArchive)();
+ ar->vm = vm;
ar->name = archname;
- ArrayUInt8* bytes = Reader::openFile(archname);
+ ArrayUInt8* bytes = Reader::openFile(vm, archname);
if (bytes != 0) {
- ar->reader = Reader::allocateReader(bytes);
+ ar->reader = vm_new(vm, Reader)(bytes);
ar->findOfscd();
if (ar->ofscd > -1) {
- ar->filetable = ZipFileMap::allocate();
+ ar->filetable = vm_new(vm, ZipFileMap)();
ar->addFiles();
return ar;
}
@@ -136,7 +138,7 @@
while (true) {
if (memcmp(&(reader->bytes->elements[temp]), HDR_CENTRAL, 4)) return;
- ZipFile* ptr = gc_new(ZipFile)();
+ ZipFile* ptr = vm_new(vm, ZipFile)();
reader->cursor = temp + 4 + C_COMPRESSION_METHOD;
ptr->compressionMethod = readEndianDep2(reader);
Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=49477&r1=49476&r2=49477&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Thu Apr 10 06:35:38 2008
@@ -49,6 +49,7 @@
ZipFileMap* filetable;
char* name;
Reader* reader;
+ Jnjvm* vm;
virtual void print(mvm::PrintBuffer* buf) const {
buf->write("ZipArchive<");
@@ -57,8 +58,8 @@
}
virtual void tracer(size_t sz);
- static ZipArchive* hashedArchive(char* archname);
- static ZipArchive* singleArchive(char* archname);
+ static ZipArchive* hashedArchive(Jnjvm* vm, char* archname);
+ static ZipArchive* singleArchive(Jnjvm* vm, char* archname);
ZipFile* getFile(const char* filename);
int readFile(ArrayUInt8* array, const ZipFile* file);
void remove();
More information about the llvm-commits
mailing list