[vmkit-commits] [vmkit] r57436 - in /vmkit/trunk: include/mvm/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Mon Oct 13 05:29:02 PDT 2008
Author: geoffray
Date: Mon Oct 13 07:29:01 2008
New Revision: 57436
URL: http://llvm.org/viewvc/llvm-project?rev=57436&view=rev
Log:
Isolate allocation of objects per classloader or per jvm.
Modified:
vmkit/trunk/include/mvm/Allocator.h
vmkit/trunk/include/mvm/JIT.h
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/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/JavaConstantPool.h
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.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/JavaTypes.h
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
Modified: vmkit/trunk/include/mvm/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Allocator.h (original)
+++ vmkit/trunk/include/mvm/Allocator.h Mon Oct 13 07:29:01 2008
@@ -48,6 +48,14 @@
void freePermanentMemory(void* obj) {
return free(obj);
}
+
+ void* allocateTemporaryMemory(unsigned int sz) {
+ return malloc(sz);
+ }
+
+ void freeTemporaryMemory(void* obj) {
+ return free(obj);
+ }
};
class PermanentObject {
Modified: vmkit/trunk/include/mvm/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/JIT.h (original)
+++ vmkit/trunk/include/mvm/JIT.h Mon Oct 13 07:29:01 2008
@@ -24,6 +24,7 @@
#include "types.h"
+#include "mvm/Allocator.h"
#include "mvm/Method.h"
#include "mvm/MvmMemoryManager.h"
#include "mvm/Threads/Locks.h"
@@ -35,7 +36,7 @@
/// JITInfo - This class can be derived from to hold private JIT-specific
/// information. Objects of type are accessed/created with
/// <Class>::getInfo and destroyed when the <Class> object is destroyed.
-struct JITInfo {
+struct JITInfo : public mvm::PermanentObject {
virtual ~JITInfo() {}
};
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Mon Oct 13 07:29:01 2008
@@ -40,16 +40,11 @@
return (jobject)(JavaThread::currentThread());
}
-typedef struct arg_thread_t {
- JavaObject* vmThread;
- JavaThread* intern;
-} arg_thread_t;
-
-static void start(arg_thread_t* arg) {
+static void start(JavaObject* vmThread) {
int argc;
- JavaObject* vmThread = arg->vmThread;
- JavaThread* intern = arg->intern;
- free(arg);
+ Classpath* upcalls = vmThread->classOf->classLoader->bootstrapLoader->upcalls;
+ JavaThread* intern = (JavaThread*)upcalls->vmdataVMThread->getObjectField(vmThread);
+ Jnjvm* isolate = intern->isolate;
mvm::Thread::set(intern);
#ifdef MULTIPLE_GC
intern->GC->inject_my_thread(&argc);
@@ -57,7 +52,6 @@
Collector::inject_my_thread(&argc);
#endif
UserClass* vmthClass = (UserClass*)vmThread->classOf;
- Jnjvm* isolate = intern->isolate;
JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread);
ThreadSystem& ts = isolate->threadSystem;
bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread);
@@ -115,14 +109,11 @@
th->initialise(javaThread, vm);
vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)th);
int tid = 0;
- arg_thread_t* arg = (arg_thread_t*)malloc(sizeof(arg_thread_t));
- arg->intern = th;
- arg->vmThread = vmThread;
#ifdef MULTIPLE_GC
th->GC = mvm::Thread::get()->GC;
#endif
- mvm::Thread::start(&tid, (int (*)(void *))start, (void*)arg);
+ mvm::Thread::start(&tid, (int (*)(void *))start, (void*)vmThread);
}
JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Mon Oct 13 07:29:01 2008
@@ -38,7 +38,8 @@
#endif
jobject throwable) {
Jnjvm* vm = JavaThread::get()->isolate;
- int** stack = (int**)malloc(sizeof(int*) * 100);
+ int** stack =
+ (int**)vm->allocator->allocateTemporaryMemory(sizeof(int*) * 100);
int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100);
stack[real_size] = 0;
JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
@@ -115,7 +116,7 @@
}
}
jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0);
- free(stack);
+ vm->allocator->freeTemporaryMemory(stack);
return res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Mon Oct 13 07:29:01 2008
@@ -108,7 +108,6 @@
#endif
}
-/// Currently, this uses malloc/free. This should use a custom memory pool.
void* UTF8::operator new(size_t sz, mvm::Allocator* allocator, sint32 size) {
return allocator->allocatePermanentMemory(sz + size * sizeof(uint16));
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Mon Oct 13 07:29:01 2008
@@ -27,7 +27,6 @@
using namespace jnjvm;
Enveloppe::~Enveloppe() {
- delete cacheLock;
CacheNode* cache = firstCache;
CacheNode* next = firstCache;
while(next) {
@@ -41,15 +40,15 @@
lastCible = 0;
methPtr = 0;
next = 0;
+ enveloppe = E;
#ifdef ISOLATE_SHARING
definingCtp = 0;
#endif
- enveloppe = E;
}
Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) {
- firstCache = new CacheNode(this);
- cacheLock = mvm::Lock::allocNormal();
+ mvm::Allocator* allocator = ctp->classDef->classLoader->allocator;
+ firstCache = new(allocator) CacheNode(this);
ctpInfo = ctp;
index = i;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Mon Oct 13 07:29:01 2008
@@ -21,6 +21,7 @@
#ifndef JNJVM_JAVA_CACHE_H
#define JNJVM_JAVA_CACHE_H
+#include "mvm/Allocator.h"
#include "mvm/Object.h"
#include "mvm/PrintBuffer.h"
#include "mvm/Threads/Locks.h"
@@ -36,7 +37,7 @@
class UserConstantPool;
/// CacheNode - A {class, method pointer} pair.
-class CacheNode {
+class CacheNode : public mvm::PermanentObject {
public:
/// methPtr - The method pointer of this cache.
@@ -62,7 +63,7 @@
};
/// Enveloppe - A reference to the linked list of CacheNode.
-class Enveloppe {
+class Enveloppe : public mvm::PermanentObject {
public:
/// ~Enveloppe - Deletes all CacheNode in the linked list.
@@ -79,7 +80,7 @@
/// cacheLock - The linked list may be modified by concurrent thread. This
/// lock ensures that the list stays consistent.
- mvm::Lock* cacheLock;
+ mvm::LockNormal cacheLock;
/// index - The index in the constant pool of the interface method.
uint32 index;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 13 07:29:01 2008
@@ -279,7 +279,8 @@
uint32 nb) :
CommonClass(loader, n, false) {
- display = new CommonClass*[1];
+ display = (CommonClass**)
+ loader->allocator->allocatePermanentMemory(sizeof(CommonClass*));
display[0] = this;
primitive = true;
status = ready;
@@ -308,7 +309,8 @@
super = ClassArray::SuperArray;
interfaces = ClassArray::InterfacesArray;
depth = 1;
- display = new CommonClass*[2];
+ display = (CommonClass**)
+ loader->allocator->allocatePermanentMemory(2 * sizeof(CommonClass*));
display[0] = ClassArray::SuperArray;
display[1] = this;
access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC;
@@ -625,7 +627,7 @@
method_iterator End = map.end();
method_iterator I = map.find(CC);
if (I == End) {
- JavaMethod* method = new JavaMethod();
+ JavaMethod* method = new(classLoader->allocator) JavaMethod();
method->name = name;
method->type = type;
method->classDef = (Class*)this;
@@ -649,7 +651,7 @@
field_iterator End = map.end();
field_iterator I = map.find(CC);
if (I == End) {
- JavaField* field = new JavaField();
+ JavaField* field = new(classLoader->allocator) JavaField();
field->name = name;
field->type = type;
field->classDef = (Class*)this;
@@ -682,12 +684,15 @@
const UTF8* superUTF8 = getSuperUTF8();
if (superUTF8 == 0) {
depth = 0;
- display = new UserCommonClass*[1];
+ display = (CommonClass**)
+ classLoader->allocator->allocatePermanentMemory(sizeof(CommonClass*));
display[0] = this;
} else {
super = classLoader->loadName(superUTF8, true, true);
depth = super->depth + 1;
- display = new UserCommonClass*[depth + 1];
+ mvm::Allocator* allocator = classLoader->allocator;
+ display = (CommonClass**)
+ allocator->allocatePermanentMemory(sizeof(CommonClass*) * (depth + 1));
memcpy(display, super->display, depth * sizeof(UserCommonClass*));
display[depth] = this;
}
@@ -703,7 +708,8 @@
for (int i = 0; i < nba; i++) {
const UTF8* attName = ctpInfo->UTF8At(reader.readU2());
uint32 attLen = reader.readU4();
- Attribut* att = new Attribut(attName, attLen, reader.cursor);
+ Attribut* att = new(classLoader->allocator) Attribut(attName, attLen,
+ reader.cursor);
attr.push_back(att);
reader.seek(attLen, Reader::SeekCur);
}
@@ -749,7 +755,9 @@
}
minor = reader.readU2();
major = reader.readU2();
- ctpInfo = new JavaConstantPool(this, reader);
+ uint32 ctpSize = reader.readU2();
+ ctpInfo = new(classLoader->allocator, ctpSize) JavaConstantPool(this, reader,
+ ctpSize);
access = reader.readU2();
if (!isPublic(access)) access |= ACC_PRIVATE;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 13 07:29:01 2008
@@ -63,7 +63,7 @@
/// Attribut - This class represents JVM attributes to Java class, methods and
/// fields located in the .class file.
///
-class Attribut {
+class Attribut : public mvm::PermanentObject {
public:
/// name - The name of the attribut. These are specified in the JVM book.
@@ -521,6 +521,10 @@
ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name, uint32 nb);
static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls);
+
+ void* operator new(size_t sz, mvm::Allocator* allocator) {
+ return allocator->allocatePermanentMemory(sz);
+ }
};
@@ -690,7 +694,7 @@
template<typename Ty>
Ty *getInfo() {
if (!JInfo) {
- JInfo = new Ty(this);
+ JInfo = new(classLoader->allocator) Ty(this);
}
assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
@@ -769,7 +773,7 @@
/// JavaMethod - This class represents Java methods.
///
-class JavaMethod {
+class JavaMethod : public mvm::PermanentObject {
friend class CommonClass;
private:
@@ -912,7 +916,7 @@
template<typename Ty>
Ty *getInfo() {
if (!JInfo) {
- JInfo = new Ty(this);
+ JInfo = new(classDef->classLoader->allocator) Ty(this);
}
assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
@@ -924,7 +928,7 @@
/// JavaField - This class represents a Java field.
///
-class JavaField {
+class JavaField : public mvm::PermanentObject {
friend class CommonClass;
private:
/// _signature - The signature of the field. Null if not resolved.
@@ -1021,7 +1025,7 @@
template<typename Ty>
Ty *getInfo() {
if (!JInfo) {
- JInfo = new Ty(this);
+ JInfo = new(classDef->classLoader->allocator) Ty(this);
}
assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 13 07:29:01 2008
@@ -185,16 +185,23 @@
return 2;
}
-JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader) {
- ctpSize = reader.readU2();
+
+void* JavaConstantPool::operator new(size_t sz, mvm::Allocator* allocator,
+ uint32 ctpSize) {
+ uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8));
+ return allocator->allocatePermanentMemory(size);
+}
+
+JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader, uint32 size) {
+ ctpSize = size;
classDef = cl;
- ctpRes = new void*[ctpSize];
- ctpDef = new sint32[ctpSize];
- ctpType = new uint8[ctpSize];
- memset(ctpRes, 0, sizeof(void**) * ctpSize);
- memset(ctpDef, 0, sizeof(sint32) * ctpSize);
- memset(ctpType, 0, sizeof(uint8) * ctpSize);
+ ctpType = (uint8*)((uint64)this + sizeof(JavaConstantPool));
+ ctpDef = (sint32*)((uint64)ctpType + ctpSize * sizeof(uint8));
+ ctpRes = (void**)((uint64)ctpDef + ctpSize * sizeof(sint32));
+
+ memset(ctpType, 0,
+ ctpSize * (sizeof(uint8) + sizeof(sint32) + sizeof(void*)));
uint32 cur = 1;
while (cur < ctpSize) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Mon Oct 13 07:29:01 2008
@@ -33,7 +33,7 @@
/// JavaConstantPool - This class represents a Java constant pool, a place where
/// a Java class makes external references such as classes and methods and
/// stores constants such as integers or UTF8s.
-class JavaConstantPool {
+class JavaConstantPool : public mvm::PermanentObject {
public:
/// classDef - The owning class of this constant pool.
@@ -58,6 +58,10 @@
///
void** ctpRes;
+ /// operator new - Redefine the operator to allocate the arrays of a
+ /// constant pool inline.
+ void* operator new(size_t sz, mvm::Allocator* allocator, uint32 ctpSize);
+
/// CtpReaderClass - Reads a class entry.
static uint32 CtpReaderClass(JavaConstantPool* ctp, Reader& reader,
uint32 index);
@@ -254,24 +258,16 @@
/// JavaConstantPool - Default constructor.
///
- JavaConstantPool() {
- ctpRes = 0;
- ctpType = 0;
- ctpDef = 0;
- }
+ JavaConstantPool() {}
/// JavaConstantPool - Reads the bytecode of the class to get
/// the initial types and constants definitions.
///
- JavaConstantPool(Class*, Reader& reader);
+ JavaConstantPool(Class*, Reader& reader, uint32 ctpSize);
/// ~JavaConstantPool - Delete the constant pool.
///
- ~JavaConstantPool() {
- delete ctpRes;
- delete ctpDef;
- delete ctpType;
- }
+ ~JavaConstantPool() {}
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Oct 13 07:29:01 2008
@@ -53,6 +53,7 @@
INIT(Jnjvm);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
+ INIT(LockObj);
#ifdef ISOLATE_SHARING
INIT(JnjvmSharedLoader);
INIT(SharedClassByteMap);
@@ -85,9 +86,10 @@
JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader();
}
#endif
-
+
+ mvm::Allocator* allocator = new mvm::Allocator();
JnjvmBootstrapLoader* JCL = bootstrapLoader =
- JnjvmBootstrapLoader::createBootstrapLoader();
+ gc_new(JnjvmBootstrapLoader)(allocator);
// Create the name of char arrays.
const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 13 07:29:01 2008
@@ -2018,7 +2018,9 @@
#ifndef ISOLATE_SHARING
// ok now the cache
- Enveloppe* enveloppe = new Enveloppe(compilingClass->ctpInfo, index);
+ mvm::Allocator* allocator = compilingClass->classLoader->allocator;
+ Enveloppe* enveloppe =
+ new(allocator) Enveloppe(compilingClass->ctpInfo, index);
compilingMethod->caches.push_back(enveloppe);
Value* llvmEnv =
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Mon Oct 13 07:29:01 2008
@@ -70,9 +70,11 @@
}
LockObj* LockObj::allocate() {
+#ifdef USE_GC_BOEHM
LockObj* res = new LockObj();
- res->lock = mvm::Lock::allocRecursive();
- res->varcond = 0;
+#else
+ LockObj* res = gc_new(LockObj)();
+#endif
return res;
}
@@ -89,7 +91,7 @@
void JavaObject::overflowThinlock() {
LockObj* obj = LockObj::allocate();
- mvm::LockRecursive::my_lock_all(obj->lock, 257);
+ mvm::LockRecursive::my_lock_all(&obj->lock, 257);
lock = ((uint32)obj >> 1) | 0x80000000;
}
@@ -149,7 +151,7 @@
LockObj* obj = LockObj::allocate();
uint32 val = (((uint32) obj) >> 1) | 0x80000000;
uint32 count = lock & 0xFF;
- mvm::LockRecursive::my_lock_all(obj->lock, count + 1);
+ mvm::LockRecursive::my_lock_all(&obj->lock, count + 1);
lock = val;
return obj;
} else {
@@ -177,9 +179,9 @@
thread->interruptFlag = 0;
thread->isolate->interruptedException(this);
} else {
- unsigned int recur = mvm::LockRecursive::recursion_count(l->lock);
+ unsigned int recur = mvm::LockRecursive::recursion_count(&l->lock);
bool timeout = false;
- mvm::LockRecursive::my_unlock_all(l->lock);
+ mvm::LockRecursive::my_unlock_all(&l->lock);
JavaCond* cond = l->getCond();
cond->wait(thread);
thread->state = JavaThread::StateWaiting;
@@ -192,7 +194,7 @@
bool interrupted = (thread->interruptFlag != 0);
mutexThread->unlock();
- mvm::LockRecursive::my_lock_all(l->lock, recur);
+ mvm::LockRecursive::my_lock_all(&l->lock, recur);
if (interrupted || timeout) {
cond->remove(thread);
@@ -235,13 +237,3 @@
JavaThread::get()->isolate->illegalMonitorStateException(this);
}
}
-
-LockObj::~LockObj() {
- if (varcond) delete varcond;
- delete lock;
-}
-
-LockObj::LockObj() {
- varcond = 0;
- lock = 0;
-}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Mon Oct 13 07:29:01 2008
@@ -58,7 +58,7 @@
/// LockObj - This class represents a Java monitor.
///
-class LockObj {
+class LockObj : public mvm::Object {
friend class JavaObject;
@@ -67,11 +67,11 @@
/// lock - The internal lock of this object lock.
///
- mvm::Lock *lock;
+ mvm::LockRecursive lock;
/// varcond - The condition variable for wait, notify and notifyAll calls.
///
- JavaCond* varcond;
+ JavaCond varcond;
/// allocate - Allocates a lock object. Only the internal lock is allocated.
///
@@ -85,32 +85,34 @@
/// acquire - Acquires the lock.
///
void acquire() {
- lock->lock();
+ lock.lock();
}
/// release - Releases the lock.
///
void release() {
- lock->unlock();
+ lock.unlock();
}
/// owner - Returns if the current thread owns this lock.
///
bool owner() {
- return mvm::Lock::selfOwner(lock);
+ return mvm::Lock::selfOwner(&lock);
}
/// getCond - Returns the conditation variable of this lock, allocating it
/// if non-existant.
///
JavaCond* getCond() {
- if (!varcond) varcond = new JavaCond();
- return varcond;
+ return &varcond;
}
public:
- ~LockObj();
- LockObj();
+
+ static VirtualTable* VT;
+
+ ~LockObj() {}
+ LockObj() {}
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Mon Oct 13 07:29:01 2008
@@ -42,7 +42,7 @@
ctpInfo->resolveMethod(index, cl, utf8, sign);
assert(obj->classOf->isReady() && "Class not ready in a virtual lookup.");
- enveloppe->cacheLock->lock();
+ enveloppe->cacheLock.lock();
CacheNode* rcache = 0;
CacheNode* tmp = enveloppe->firstCache;
CacheNode* last = tmp;
@@ -66,7 +66,8 @@
"Class not ready in a virtual lookup.");
#endif
if (cache->methPtr) {
- rcache = new CacheNode(enveloppe);
+ JnjvmClassLoader* loader = ctpInfo->classDef->classLoader;
+ rcache = new(loader->allocator) CacheNode(enveloppe);
} else {
rcache = cache;
}
@@ -86,7 +87,7 @@
rcache->next = f;
}
- enveloppe->cacheLock->unlock();
+ enveloppe->cacheLock.unlock();
return rcache->methPtr;
}
@@ -149,7 +150,8 @@
#ifdef ISOLATE_SHARING
extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) {
UserConstantPool* ctpInfo = cl->getConstantPool();
- Enveloppe* enveloppe = new Enveloppe(ctpInfo, index);
+ mvm::Allocator* allocator = cl->classLoader->allocator;
+ Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index);
ctpInfo->ctpRes[index] = enveloppe;
return (void*)enveloppe;
}
@@ -275,7 +277,8 @@
extern "C" void* getSJLJBuffer() {
JavaThread* th = JavaThread::get();
- void** buf = (void**)malloc(sizeof(jmp_buf));
+ mvm::Allocator* allocator = th->isolate->allocator;
+ void** buf = (void**)allocator->allocatePermanentMemory(sizeof(jmp_buf));
th->sjlj_buffers.push_back((jmp_buf*)buf);
return (void*)buf;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Mon Oct 13 07:29:01 2008
@@ -18,7 +18,8 @@
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
UserClass* cl = vm->upcalls->newString;
- JavaString* res = (JavaString*)malloc(cl->getVirtualSize());
+ JavaString* res =
+ (JavaString*)vm->allocator->allocatePermanentMemory(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.
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Mon Oct 13 07:29:01 2008
@@ -189,25 +189,6 @@
}
-Typedef* Typedef::constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm) {
- short int cur = name->elements[0];
- Typedef* res = 0;
- switch (cur) {
- case I_TAB :
- res = new ArrayTypedef(name);
- break;
- case I_REF :
- res = new ObjectTypedef(name, map);
- break;
- default :
- UserClassPrimitive* cl = vm->getPrimitiveClass((char)name->elements[0]);
- assert(cl && "No primitive");
- bool unsign = (cl == vm->upcalls->OfChar || cl == vm->upcalls->OfBool);
- res = new PrimitiveTypedef(name, cl, unsign, cur);
- }
- return res;
-}
-
ObjectTypedef::ObjectTypedef(const UTF8* name, UTF8Map* map) {
keyName = name;
pseudoAssocClassName = name->extract(map, 1, name->size - 1);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Mon Oct 13 07:29:01 2008
@@ -12,9 +12,12 @@
#include "types.h"
+#include "mvm/Allocator.h"
#include "mvm/JIT.h"
#include "mvm/Object.h"
+#include "JnjvmClassLoader.h"
+
namespace jnjvm {
class Classpath;
@@ -65,7 +68,7 @@
/// which has not been loaded yet. Typedefs are hashed on the name of the class.
/// Hashing is for memory purposes, not for comparison.
///
-class Typedef {
+class Typedef : public mvm::PermanentObject {
public:
/// keyName - The name of the Typedef. It is the representation of a class
@@ -91,10 +94,6 @@
///
virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const = 0;
- /// Typedef - Create a new Typedef.
- ///
- static Typedef* constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm);
-
virtual bool trace() const = 0;
virtual bool isPrimitive() const {
@@ -195,22 +194,6 @@
return charId == I_DOUBLE;
}
- /// JInfo - Holds info useful for the JIT.
- ///
- mvm::JITInfo* JInfo;
-
- /// getInfo - Get the JIT info of this signature. The info is created lazely.
- ///
- template<typename Ty>
- Ty *getInfo() {
- if (!JInfo) {
- JInfo = new Ty(this);
- }
-
- assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
- "Invalid concrete type or multiple inheritence for getInfo");
- return static_cast<Ty*>(JInfo);
- }
};
class ArrayTypedef : public Typedef {
@@ -262,7 +245,7 @@
/// Java signature. Signdefs are hashed for memory purposes, not equality
/// purposes.
///
-class Signdef {
+class Signdef : public mvm::PermanentObject {
private:
/// _staticCallBuf - A dynamically generated method which calls a static Java
@@ -384,7 +367,7 @@
template<typename Ty>
Ty *getInfo() {
if (!JInfo) {
- JInfo = new Ty(this);
+ JInfo = new(initialLoader->allocator) Ty(this);
}
assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Mon Oct 13 07:29:01 2008
@@ -10,13 +10,16 @@
#ifndef JNJVM_JAVA_UPCALLS_H
#define JNJVM_JAVA_UPCALLS_H
+#include "mvm/Allocator.h"
+
#include "JnjvmConfig.h"
#define UPCALL_CLASS(vm, name) \
vm->loadName(vm->asciizConstructUTF8(name), false, false)
#define UPCALL_PRIMITIVE_CLASS(loader, name, nb) \
- new UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb)
+ new(loader->allocator) \
+ UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb) \
#define UPCALL_FIELD(vm, cl, name, type, acc) \
UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \
@@ -54,7 +57,7 @@
class Class;
class ClassArray;
-class Classpath {
+class Classpath : public mvm::PermanentObject {
public:
ISOLATE_STATIC UserClass* newClassLoader;
ISOLATE_STATIC JavaMethod* getSystemClassLoader;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 13 07:29:01 2008
@@ -411,7 +411,8 @@
}
-static char* findInformation(ArrayUInt8* manifest, const char* entry, uint32 len) {
+static char* findInformation(Jnjvm* vm, ArrayUInt8* manifest, const char* entry,
+ uint32 len) {
uint8* ptr = manifest->elements;
sint32 index = sys_strnstr((char*)ptr, entry);
if (index != -1) {
@@ -421,7 +422,7 @@
else end += index;
sint32 length = end - index - 1;
- char* name = (char*)malloc(length + 1);
+ char* name = (char*)vm->allocator->allocatePermanentMemory(length + 1);
memcpy(name, &(ptr[index]), length);
name[length] = 0;
return name;
@@ -433,14 +434,13 @@
void ClArgumentsInfo::extractClassFromJar(Jnjvm* vm, int argc, char** argv,
int i) {
char* jarFile = argv[i];
- char* temp =
- (char*)malloc(2 + strlen(vm->classpath) + strlen(jarFile));
+ uint32 size = 2 + strlen(vm->classpath) + strlen(jarFile);
+ char* temp = (char*)vm->allocator->allocatePermanentMemory(size);
sprintf(temp, "%s:%s", vm->classpath, jarFile);
vm->setClasspath(temp);
- ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader,
- jarFile);
+ ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile);
ZipArchive archive(bytes, vm->allocator);
if (archive.getOfscd() != -1) {
@@ -450,7 +450,7 @@
ArrayUInt8* res = (ArrayUInt8*)array->doNew(file->ucsize, vm);
int ok = archive.readFile(res, file);
if (ok) {
- char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS);
+ char* mainClass = findInformation(vm, res, MAIN_CLASS, LENGTH_MAIN_CLASS);
if (mainClass) {
className = mainClass;
} else {
@@ -776,13 +776,14 @@
argv = argv + pos - 1;
argc = argc - pos + 1;
- bootstrapThread = allocator_new(&allocator, JavaThread)();
+ bootstrapThread = allocator_new(allocator, JavaThread)();
bootstrapThread->initialise(0, this);
bootstrapThread->baseSP = mvm::Thread::get()->baseSP;
JavaThread::set(bootstrapThread);
bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
loadBootstrap();
+
#ifdef SERVICE_VM
ServiceDomain::initialise((ServiceDomain*)this);
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 13 07:29:01 2008
@@ -38,35 +38,32 @@
extern const char* GNUClasspathGlibj;
extern const char* GNUClasspathLibs;
-JnjvmBootstrapLoader* JnjvmBootstrapLoader::createBootstrapLoader() {
+JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::Allocator* A) {
- JnjvmBootstrapLoader* JCL = gc_new(JnjvmBootstrapLoader)();
+ allocator = A;
JnjvmModule::initialise();
- JCL->TheModule = new JnjvmModule("Bootstrap JnJVM");
- JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule);
-
- JCL->allocator = new mvm::Allocator();
+ TheModule = new JnjvmModule("Bootstrap JnJVM");
+ TheModuleProvider = new JnjvmModuleProvider(TheModule);
- JCL->hashUTF8 = new(JCL->allocator) UTF8Map(JCL->allocator, 0);
- JCL->classes = new(JCL->allocator) ClassMap();
- JCL->javaTypes = new(JCL->allocator) TypeMap();
- JCL->javaSignatures = new(JCL->allocator) SignMap();
+ hashUTF8 = new(allocator) UTF8Map(allocator, 0);
+ classes = new(allocator) ClassMap();
+ javaTypes = new(allocator) TypeMap();
+ javaSignatures = new(allocator) SignMap();
- JCL->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH");
- if (!JCL->bootClasspathEnv) {
- JCL->bootClasspathEnv = GNUClasspathGlibj;
+ bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH");
+ if (!bootClasspathEnv) {
+ bootClasspathEnv = GNUClasspathGlibj;
}
- JCL->libClasspathEnv = getenv("JNJVM_LIBCLASSPATH");
- if (!JCL->libClasspathEnv) {
- JCL->libClasspathEnv = GNUClasspathLibs;
+ libClasspathEnv = getenv("JNJVM_LIBCLASSPATH");
+ if (!libClasspathEnv) {
+ libClasspathEnv = GNUClasspathLibs;
}
- JCL->analyseClasspathEnv(JCL->bootClasspathEnv);
+ analyseClasspathEnv(bootClasspathEnv);
- JCL->upcalls = new Classpath();
- JCL->bootstrapLoader = JCL;
- return JCL;
+ upcalls = new(allocator) Classpath();
+ bootstrapLoader = this;
}
JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader,
@@ -76,7 +73,8 @@
bootstrapLoader = JCL.bootstrapLoader;
allocator = new mvm::Allocator();
- hashUTF8 = new(allocator) UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar);
+ hashUTF8 = new(allocator) UTF8Map(allocator,
+ bootstrapLoader->upcalls->ArrayOfChar);
classes = new(allocator) ClassMap();
javaTypes = new(allocator) TypeMap();
javaSignatures = new(allocator) SignMap();
@@ -168,10 +166,11 @@
UserClass* cl = internalLoad(name);
if (!cl && doThrow) {
+ Jnjvm* vm = JavaThread::get()->isolate;
if (!(name->equals(Jnjvm::NoClassDefFoundError))) {
- JavaThread::get()->isolate->unknownError("Unable to load NoClassDefFoundError");
+ vm->unknownError("Unable to load NoClassDefFoundError");
}
- JavaThread::get()->isolate->noClassDefFoundError("unable to load %s", name->printString());
+ vm->noClassDefFoundError("unable to load %s", name->printString());
}
if (cl && doResolve) cl->resolveClass();
@@ -243,8 +242,9 @@
}
}
-UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
- bool doResolve, bool doThrow) {
+UserCommonClass*
+JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
+ bool doResolve, bool doThrow) {
const UTF8* name = 0;
@@ -294,7 +294,8 @@
return ld->constructArray(name, cl);
}
-UserClass* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) {
+UserClass* JnjvmClassLoader::constructClass(const UTF8* name,
+ ArrayUInt8* bytes) {
assert(bytes && "constructing a class without bytes");
classes->lock.lock();
ClassMap::iterator End = classes->map.end();
@@ -329,11 +330,33 @@
return res;
}
+Typedef* JnjvmClassLoader::internalConstructType(const UTF8* name) {
+ short int cur = name->elements[0];
+ Typedef* res = 0;
+ switch (cur) {
+ case I_TAB :
+ res = new(allocator) ArrayTypedef(name);
+ break;
+ case I_REF :
+ res = new(allocator) ObjectTypedef(name, hashUTF8);
+ break;
+ default :
+ UserClassPrimitive* cl =
+ isolate->getPrimitiveClass((char)name->elements[0]);
+ assert(cl && "No primitive");
+ bool unsign = (cl == isolate->upcalls->OfChar ||
+ cl == isolate->upcalls->OfBool);
+ res = new(allocator) PrimitiveTypedef(name, cl, unsign, cur);
+ }
+ return res;
+}
+
+
Typedef* JnjvmClassLoader::constructType(const UTF8* name) {
javaTypes->lock.lock();
Typedef* res = javaTypes->lookup(name);
if (res == 0) {
- res = Typedef::constructType(name, hashUTF8, isolate);
+ res = internalConstructType(name);
javaTypes->hash(name, res);
}
javaTypes->lock.unlock();
@@ -344,7 +367,7 @@
javaSignatures->lock.lock();
Signdef* res = javaSignatures->lookup(name);
if (res == 0) {
- res = new Signdef(name, this);
+ res = new(allocator) Signdef(name, this);
javaSignatures->hash(name, res);
}
javaSignatures->lock.unlock();
@@ -352,7 +375,8 @@
}
-JnjvmClassLoader* JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) {
+JnjvmClassLoader*
+JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) {
if (loader == 0)
return vm->bootstrapLoader;
@@ -362,7 +386,7 @@
(JnjvmClassLoader*)(upcalls->vmdataClassLoader->getObjectField(loader));
if (!JCL) {
- JCL = gc_new(JnjvmClassLoader)(*vm->bootstrapLoader, loader, JavaThread::get()->isolate);
+ JCL = gc_new(JnjvmClassLoader)(*vm->bootstrapLoader, loader, vm);
(upcalls->vmdataClassLoader->setObjectField(loader, (JavaObject*)JCL));
}
@@ -373,7 +397,8 @@
return hashUTF8->lookupOrCreateAsciiz(asciiz);
}
-const UTF8* JnjvmClassLoader::readerConstructUTF8(const uint16* buf, uint32 size) {
+const UTF8* JnjvmClassLoader::readerConstructUTF8(const uint16* buf,
+ uint32 size) {
return hashUTF8->lookupOrCreateReader(buf, size);
}
@@ -407,7 +432,7 @@
stat(rp, &st);
if ((st.st_mode & S_IFMT) == S_IFDIR) {
unsigned int len = strlen(rp);
- char* temp = (char*)malloc(len + 2);
+ char* temp = (char*)allocator->allocatePermanentMemory(len + 2);
memcpy(temp, rp, len);
temp[len] = Jnjvm::dirSeparator[0];
temp[len + 1] = 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 13 07:29:01 2008
@@ -66,6 +66,11 @@
///
virtual UserClass* internalLoad(const UTF8* utf8);
+ /// internalConstructType - Hashes a Typedef, an internal representation of
+ /// a class still not loaded.
+ ///
+ Typedef* internalConstructType(const UTF8 * name);
+
/// JnjvmClassLoader - Allocate a user-defined class loader. Called on
/// first use of a Java class loader.
///
@@ -268,7 +273,8 @@
/// createBootstrapLoader - Creates the bootstrap loader, first thing
/// to do before any execution of a JVM.
///
- static JnjvmBootstrapLoader* createBootstrapLoader();
+ JnjvmBootstrapLoader(mvm::Allocator*);
+ JnjvmBootstrapLoader() {}
/// upcalls - Upcall classes, fields and methods so that C++ code can call
/// Java code.
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 13 07:29:01 2008
@@ -197,7 +197,9 @@
CommonClass::method_iterator meths) {
if (meths == cl->virtualMethods.end()) {
uint64 size = cl->virtualTableSize;
- VirtualTable* VT = (VirtualTable*)malloc(size * sizeof(void*));
+ mvm::Allocator* allocator = cl->classLoader->allocator;
+ VirtualTable* VT = (VirtualTable*)
+ allocator->allocatePermanentMemory(size * sizeof(void*));
if (!VT) JavaThread::get()->isolate->outOfMemoryError(size * sizeof(void*));
if (cl->super) {
Class* super = (Class*)cl->super;
@@ -263,7 +265,8 @@
#ifndef WITHOUT_VTABLE
if (stat) {
#endif
- res = (VirtualTable*)malloc(VT_SIZE);
+ mvm::Allocator* allocator = cl->classLoader->allocator;
+ res = (VirtualTable*)allocator->allocatePermanentMemory(VT_SIZE);
memcpy(res, JavaObject::VT, VT_SIZE);
#ifndef WITHOUT_VTABLE
} else {
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57436&r1=57435&r2=57436&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Mon Oct 13 07:29:01 2008
@@ -39,6 +39,7 @@
INIT(Jnjvm);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
+ INIT(LockObj);
#if defined(ISOLATE_SHARING)
INIT(JnjvmSharedLoader);
INIT(SharedClassByteMap);
@@ -57,6 +58,8 @@
for (sint32 i = 0; i < size; i++) {
if (elements[i]) elements[i]->MARK_AND_TRACE;
}
+ LockObj* l = lockObj();
+ if (l) l->MARK_AND_TRACE;
}
void JavaArray::TRACER {}
@@ -91,6 +94,8 @@
void JavaObject::TRACER {
classOf->MARK_AND_TRACE;
+ LockObj* l = lockObj();
+ if (l) l->MARK_AND_TRACE;
}
#ifdef MULTIPLE_GC
@@ -99,6 +104,8 @@
extern "C" void JavaObjectTracer(JavaObject* obj) {
#endif
obj->classOf->MARK_AND_TRACE;
+ LockObj* l = obj->lockObj();
+ if (l) l->MARK_AND_TRACE;
}
More information about the vmkit-commits
mailing list