[vmkit-commits] [vmkit] r136592 - in /vmkit/trunk: include/j3/J3Intrinsics.h include/j3/JavaAOTCompiler.h lib/J3/Compiler/J3Intrinsics.cpp lib/J3/Compiler/JavaAOTCompiler.cpp lib/J3/LLVMRuntime/runtime-default.ll lib/J3/VMCore/JnjvmClassLoader.cpp lib/J3/VMCore/JnjvmClassLoader.h lib/J3/VMCore/LockedMap.cpp lib/J3/VMCore/LockedMap.h lib/J3/VMCore/Precompiled.cpp mmtk/mmtk-j3/Memory.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Sun Jul 31 03:54:50 PDT 2011
Author: geoffray
Date: Sun Jul 31 05:54:50 2011
New Revision: 136592
URL: http://llvm.org/viewvc/llvm-project?rev=136592&view=rev
Log:
Precompile the class map.
Modified:
vmkit/trunk/include/j3/J3Intrinsics.h
vmkit/trunk/include/j3/JavaAOTCompiler.h
vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.h
vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
Modified: vmkit/trunk/include/j3/J3Intrinsics.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/J3Intrinsics.h?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/include/j3/J3Intrinsics.h (original)
+++ vmkit/trunk/include/j3/J3Intrinsics.h Sun Jul 31 05:54:50 2011
@@ -45,6 +45,7 @@
llvm::Type* AttributType;
llvm::Type* JavaThreadType;
llvm::Type* MutatorThreadType;
+ llvm::Type* J3DenseMapType;
llvm::Function* StartJNIFunction;
llvm::Function* EndJNIFunction;
Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Sun Jul 31 05:54:50 2011
@@ -11,6 +11,7 @@
#define J3_AOT_COMPILER_H
#include "j3/JavaLLVMCompiler.h"
+#include "j3/J3DenseMap.h"
namespace j3 {
@@ -58,7 +59,7 @@
llvm::Constant* HandleMagic(JavaObject* obj, CommonClass* cl);
virtual llvm::Constant* getFinalObject(JavaObject* obj, CommonClass* cl);
virtual JavaObject* getFinalObject(llvm::Value* C);
- virtual llvm::Constant* getNativeClass(CommonClass* cl);
+ virtual llvm::GlobalVariable* getNativeClass(CommonClass* cl);
virtual llvm::Constant* getClassBytes(const UTF8* name, ClassBytes* bytes);
virtual llvm::Constant* getJavaClass(CommonClass* cl);
virtual llvm::Constant* getJavaClassPtr(CommonClass* cl);
@@ -99,6 +100,7 @@
llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
llvm::Constant* CreateConstantFromJavaConstantPool(JavaConstantPool* ctp);
+ llvm::Constant* CreateConstantFromClassMap(const J3DenseMap<const UTF8*, CommonClass*>& map);
void AddInitializerToClass(llvm::GlobalVariable* varGV, CommonClass* classDef);
llvm::Constant* getUTF8(const UTF8* val);
Modified: vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp Sun Jul 31 05:54:50 2011
@@ -97,6 +97,10 @@
CodeLineInfoType =
PointerType::getUnqual(module->getTypeByName("CodeLineInfo"));
+ J3DenseMapType =
+ PointerType::getUnqual(module->getTypeByName("J3DenseMap"));
+
+
JavaObjectNullConstant =
Constant::getNullValue(J3Intrinsics::JavaObjectType);
MaxArraySizeConstant = ConstantInt::get(Type::getInt32Ty(Context),
Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Sun Jul 31 05:54:50 2011
@@ -64,7 +64,7 @@
}
}
-Constant* JavaAOTCompiler::getNativeClass(CommonClass* classDef) {
+GlobalVariable* JavaAOTCompiler::getNativeClass(CommonClass* classDef) {
if (classDef->isClass() || isCompiling(classDef) || assumeCompiled) {
@@ -88,7 +88,7 @@
nativeClasses.insert(std::make_pair(classDef, varGV));
- if (!precompile) {
+ if (!precompile || classDef->isPrimitive()) {
AddInitializerToClass(varGV, classDef);
}
@@ -916,11 +916,7 @@
CommonClassElts.push_back(Constant::getNullValue(TempTy));
}
- // classLoader: store the static initializer, it will be overriden once
- // the class is loaded.
- Constant* loader = ConstantExpr::getBitCast(StaticInitializer,
- JavaIntrinsics.ptrType);
- CommonClassElts.push_back(loader);
+ CommonClassElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
// virtualTable
if (cl->virtualVT) {
@@ -1103,6 +1099,59 @@
return ConstantStruct::get(STy, ClassElts);
}
+Constant* JavaAOTCompiler::CreateConstantFromClassMap(const J3DenseMap<const UTF8*, CommonClass*>& map) {
+ StructType* STy =
+ dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
+ Module& Mod = *getLLVMModule();
+
+ std::vector<Constant*> elements;
+ elements.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), map.NumBuckets));
+
+ Constant* buckets;
+ if (map.NumBuckets > 0) {
+ std::vector<Constant*> TempElts;
+ ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, map.NumBuckets * 2);
+
+ for (uint32 i = 0; i < map.NumBuckets; ++i) {
+ J3Pair<const UTF8*, CommonClass*> pair = map.Buckets[i];
+ if (pair.first == &TombstoneKey) {
+ static GlobalVariable* gv =
+ new GlobalVariable(Mod, JavaIntrinsics.UTF8Type->getContainedType(0),
+ false, GlobalValue::ExternalLinkage, NULL,
+ "TombstoneKey");
+ TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, gv, JavaIntrinsics.ptrType));
+ TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
+ } else if (pair.first == &EmptyKey) {
+ static GlobalVariable* gv =
+ new GlobalVariable(Mod, JavaIntrinsics.UTF8Type->getContainedType(0),
+ false, GlobalValue::ExternalLinkage, NULL,
+ "EmptyKey");
+ TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, gv, JavaIntrinsics.ptrType));
+ TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
+ } else {
+ TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, getUTF8(pair.first), JavaIntrinsics.ptrType));
+ TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, getNativeClass(pair.second), JavaIntrinsics.ptrType));
+ }
+ }
+
+ buckets = ConstantArray::get(ATy, TempElts);
+
+ GlobalVariable* gv = new GlobalVariable(Mod, ATy, false, GlobalValue::InternalLinkage, buckets, "");
+ buckets = ConstantExpr::getCast(Instruction::BitCast, gv, JavaIntrinsics.ptrType);
+ } else {
+ buckets = Constant::getNullValue(JavaIntrinsics.ptrType);
+ }
+
+ elements.push_back(buckets);
+ elements.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), map.NumEntries));
+ elements.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), map.NumTombstones));
+ elements.push_back(ConstantInt::get(Type::getInt1Ty(getLLVMContext()), 1));
+
+ return new GlobalVariable(Mod, STy, false,
+ GlobalValue::ExternalLinkage,
+ ConstantStruct::get(STy, elements), "ClassMap");
+}
+
Constant* JavaAOTCompiler::CreateConstantFromClass(Class* cl) {
StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaClassType->getContainedType(0));
@@ -1145,25 +1194,20 @@
// virtualFields
if (cl->nbVirtualFields) {
-
for (uint32 i = 0; i < cl->nbVirtualFields; ++i) {
TempElts.push_back(CreateConstantFromJavaField(cl->virtualFields[i]));
}
-
}
// staticFields
if (cl->nbStaticFields) {
-
for (uint32 i = 0; i < cl->nbStaticFields; ++i) {
TempElts.push_back(CreateConstantFromJavaField(cl->staticFields[i]));
}
-
}
Constant* fields = 0;
if (cl->nbStaticFields + cl->nbVirtualFields) {
-
fields = ConstantArray::get(ATy, TempElts);
TempElts.clear();
fields = new GlobalVariable(Mod, ATy, false,
@@ -1744,15 +1788,8 @@
precompile = false;
std::vector<llvm::Type*> llvmArgs;
- llvmArgs.push_back(JavaIntrinsics.ptrType); // class loader.
- FunctionType* FTy = FunctionType::get(Type::getVoidTy(getLLVMContext()),
- llvmArgs, false);
-
- StaticInitializer = Function::Create(FTy, GlobalValue::InternalLinkage,
- "Init", getLLVMModule());
-
- llvmArgs.clear();
- FTy = FunctionType::get(Type::getVoidTy(getLLVMContext()), llvmArgs, false);
+ FunctionType* FTy = FunctionType::get(
+ Type::getVoidTy(getLLVMContext()), llvmArgs, false);
Callback = Function::Create(FTy, GlobalValue::ExternalLinkage,
"staticCallback", getLLVMModule());
@@ -1826,6 +1863,13 @@
Function* AddClass = Function::Create(FTy, GlobalValue::ExternalLinkage,
"vmjcAddPreCompiledClass",
getLLVMModule());
+
+ llvmArgs.clear();
+ llvmArgs.push_back(JavaIntrinsics.ptrType); // class loader.
+ FTy = FunctionType::get(Type::getVoidTy(getLLVMContext()), llvmArgs, false);
+
+ StaticInitializer = Function::Create(FTy, GlobalValue::InternalLinkage,
+ "Init", getLLVMModule());
llvmArgs.clear();
// class loader
@@ -2219,11 +2263,15 @@
getNativeClass(loader->upcalls->OfLong);
getNativeClass(loader->upcalls->OfDouble);
- // First set classes that have been more than resolved to resolved.
+ // First set all classes to resolved.
for (ClassMap::iterator i = loader->getClasses()->map.begin(),
e = loader->getClasses()->map.end(); i!= e; ++i) {
- if (i->second->isClass() && i->second->asClass()->isResolved()) {
- i->second->asClass()->setResolved();
+ if (i->second->isClass()) {
+ if (i->second->asClass()->isResolved()) {
+ i->second->asClass()->setResolved();
+ } else {
+ i->second->asClass()->resolveClass();
+ }
}
}
@@ -2263,17 +2311,12 @@
meth->code = Func;
}
- bool changed = false;
- do {
- changed = false;
- for (native_class_iterator i = nativeClasses.begin(),
- e = nativeClasses.end(); i != e; ++i) {
- if (!i->second->hasInitializer()) {
- changed = true;
- AddInitializerToClass(i->second, i->first);
- }
- }
- } while (changed);
+ // Add all class initializers.
+ for (ClassMap::iterator i = loader->getClasses()->map.begin(),
+ e = loader->getClasses()->map.end(); i!= e; ++i) {
+ GlobalVariable* gv = getNativeClass(i->second);
+ AddInitializerToClass(gv, i->second);
+ }
// Add the bootstrap classes to the image.
for (std::vector<ZipArchive*>::iterator i = loader->bootArchives.begin(),
@@ -2320,7 +2363,8 @@
loader->constructSign(loader->asciizConstructUTF8("([Ljava/lang/String;)V"));
getSignatureInfo(mainSignature)->getStaticBuf();
- CreateStaticInitializer();
+ // Emit the class map.
+ CreateConstantFromClassMap(loader->classes->map);
}
/// compileAllStubs - Compile all the native -> Java stubs.
Modified: vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll Sun Jul 31 05:54:50 2011
@@ -63,6 +63,8 @@
%JavaClassPrimitive = type { %JavaCommonClass, i32 }
%JavaClassArray = type { %JavaCommonClass, %JavaCommonClass* }
+%J3DenseMap = type { i32, i8*, i32, i32, i1 }
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;; Make sure all named types are emitted ;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -91,7 +93,8 @@
%Attribut,
%JavaThread,
%MutatorThread,
- %CodeLineInfo);
+ %CodeLineInfo,
+ %J3DenseMap);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; Constant calls for J3 runtime internal objects field accesses ;;;;;;;;;
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Sun Jul 31 05:54:50 2011
@@ -66,7 +66,6 @@
TheCompiler = Comp;
hashUTF8 = new(allocator, "UTF8Map") UTF8Map(allocator);
- classes = new(allocator, "ClassMap") ClassMap();
javaTypes = new(allocator, "TypeMap") TypeMap();
javaSignatures = new(allocator, "SignMap") SignMap();
strings = new(allocator, "StringList") StringList();
@@ -84,6 +83,7 @@
}
if (!bootLoaded) {
+ classes = new(allocator, "ClassMap") ClassMap();
// Analyze the boot classpath, we know bootstrap classes are not in the
// executable.
analyseClasspathEnv(bootClasspathEnv);
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h Sun Jul 31 05:54:50 2011
@@ -418,6 +418,7 @@
friend class ClArgumentsInfo;
friend class JavaAOTCompiler;
+ friend class Precompiled;
};
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.cpp Sun Jul 31 05:54:50 2011
@@ -13,7 +13,10 @@
#include "JavaString.h"
#include "LockedMap.h"
-using namespace j3;
+namespace j3 {
+
+extern "C" const UTF8 TombstoneKey(0);
+extern "C" const UTF8 EmptyKey(0);
bool ltarray16::operator()(const ArrayUInt16* s1, const ArrayUInt16* s2) const {
llvm_gcroot(s1, 0);
@@ -36,3 +39,5 @@
assert(&(map.find(array)->second) == &(it->second));
assert(&(map.find(array)->first) == &(it->first));
}
+
+}
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Sun Jul 31 05:54:50 2011
@@ -16,7 +16,7 @@
#ifndef JNJVM_LOCKED_MAP_H
#define JNJVM_LOCKED_MAP_H
-#include "llvm/ADT/DenseMap.h"
+#include "j3/J3DenseMap.h"
#include <map>
@@ -28,26 +28,26 @@
#include "mvm/Threads/Locks.h"
#include "UTF8.h"
-namespace llvm {
-// Provide DenseMapInfo for UTF8.
+extern "C" const j3::UTF8 TombstoneKey;
+extern "C" const j3::UTF8 EmptyKey;
+
+namespace j3 {
+
+// Provide J3DenseMapInfo for UTF8.
template<>
-struct DenseMapInfo<const j3::UTF8*> {
+struct J3DenseMapInfo<const j3::UTF8*> {
static inline const j3::UTF8* getEmptyKey() {
- static j3::UTF8 emptyKey(0);
- return &emptyKey;
+ return &EmptyKey;
}
static inline const j3::UTF8* getTombstoneKey() {
- static j3::UTF8 tombstoneKey(0);
- return &tombstoneKey;
+ return &TombstoneKey;
}
static unsigned getHashValue(const j3::UTF8* PtrVal) {
return PtrVal->hash();
}
static bool isEqual(const j3::UTF8* LHS, const j3::UTF8* RHS) { return LHS->equals(RHS); }
};
-}
-namespace j3 {
class ArrayUInt16;
class JavaString;
@@ -129,23 +129,26 @@
class ClassMap : public mvm::PermanentObject {
public:
+ ClassMap() {}
+ ClassMap(J3DenseMap<const UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
+
mvm::LockRecursive lock;
- llvm::DenseMap<const UTF8*, UserCommonClass*> map;
- typedef llvm::DenseMap<const UTF8*, UserCommonClass*>::iterator iterator;
+ J3DenseMap<const UTF8*, UserCommonClass*> map;
+ typedef J3DenseMap<const UTF8*, UserCommonClass*>::iterator iterator;
};
class TypeMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
- llvm::DenseMap<const UTF8*, Typedef*> map;
- typedef llvm::DenseMap<const UTF8*, Typedef*>::iterator iterator;
+ J3DenseMap<const UTF8*, Typedef*> map;
+ typedef J3DenseMap<const UTF8*, Typedef*>::iterator iterator;
};
class SignMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
- llvm::DenseMap<const UTF8*, Signdef*> map;
- typedef llvm::DenseMap<const UTF8*, Signdef*>::iterator iterator;
+ J3DenseMap<const UTF8*, Signdef*> map;
+ typedef J3DenseMap<const UTF8*, Signdef*>::iterator iterator;
};
} // end namespace j3
Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Sun Jul 31 05:54:50 2011
@@ -30,54 +30,6 @@
typedef void (*static_init_t)(JnjvmClassLoader*);
-bool Precompiled::Init(JnjvmBootstrapLoader* loader) {
- Class* javaLangObject = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
- void* nativeHandle = SELF_HANDLE;
- if (javaLangObject == NULL) {
- void* handle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
- if (handle != NULL) {
- nativeHandle = handle;
- javaLangObject = (Class*)dlsym(nativeHandle, "java_lang_Object");
- }
- }
-
- if (javaLangObject == NULL) {
- return false;
- }
-
- ClassArray::SuperArray = javaLangObject;
-
- // Get the native classes.
- Classpath* upcalls = loader->upcalls;
- upcalls->OfVoid = (ClassPrimitive*)dlsym(nativeHandle, "void");
- upcalls->OfBool = (ClassPrimitive*)dlsym(nativeHandle, "boolean");
- upcalls->OfByte = (ClassPrimitive*)dlsym(nativeHandle, "byte");
- upcalls->OfChar = (ClassPrimitive*)dlsym(nativeHandle, "char");
- upcalls->OfShort = (ClassPrimitive*)dlsym(nativeHandle, "short");
- upcalls->OfInt = (ClassPrimitive*)dlsym(nativeHandle, "int");
- upcalls->OfFloat = (ClassPrimitive*)dlsym(nativeHandle, "float");
- upcalls->OfLong = (ClassPrimitive*)dlsym(nativeHandle, "long");
- upcalls->OfDouble = (ClassPrimitive*)dlsym(nativeHandle, "double");
-
- // We have the java/lang/Object class, execute the static initializer.
- static_init_t init = (static_init_t)(uintptr_t)javaLangObject->classLoader;
- assert(init && "Loaded the wrong boot library");
- init(loader);
-
- // Get the base object arrays after the init, because init puts arrays
- // in the class loader map.
- upcalls->ArrayOfString =
- loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/String;"));
-
- upcalls->ArrayOfObject =
- loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/Object;"));
-
- ClassArray::InterfacesArray = upcalls->ArrayOfObject->interfaces;
-
- return true;
-}
-
-
void JnjvmClassLoader::insertAllMethodsInVM(Jnjvm* vm) {
UNIMPLEMENTED();
}
@@ -172,10 +124,6 @@
JCL->hashUTF8->insert(field.type);
}
}
-
- if (!cl->isPrimitive()) {
- JCL->getClasses()->map.insert(std::make_pair(cl->name, cl));
- }
}
@@ -370,4 +318,63 @@
}
}
+bool Precompiled::Init(JnjvmBootstrapLoader* loader) {
+ Class* javaLangObject = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
+ void* nativeHandle = SELF_HANDLE;
+ if (javaLangObject == NULL) {
+ void* handle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
+ if (handle != NULL) {
+ nativeHandle = handle;
+ javaLangObject = (Class*)dlsym(nativeHandle, "java_lang_Object");
+ }
+ }
+
+ if (javaLangObject == NULL) {
+ return false;
+ }
+
+ ClassArray::SuperArray = javaLangObject;
+
+ // Get the native classes.
+ Classpath* upcalls = loader->upcalls;
+ upcalls->OfVoid = (ClassPrimitive*)dlsym(nativeHandle, "void");
+ upcalls->OfBool = (ClassPrimitive*)dlsym(nativeHandle, "boolean");
+ upcalls->OfByte = (ClassPrimitive*)dlsym(nativeHandle, "byte");
+ upcalls->OfChar = (ClassPrimitive*)dlsym(nativeHandle, "char");
+ upcalls->OfShort = (ClassPrimitive*)dlsym(nativeHandle, "short");
+ upcalls->OfInt = (ClassPrimitive*)dlsym(nativeHandle, "int");
+ upcalls->OfFloat = (ClassPrimitive*)dlsym(nativeHandle, "float");
+ upcalls->OfLong = (ClassPrimitive*)dlsym(nativeHandle, "long");
+ upcalls->OfDouble = (ClassPrimitive*)dlsym(nativeHandle, "double");
+ upcalls->OfVoid->classLoader = loader;
+ upcalls->OfBool->classLoader = loader;
+ upcalls->OfByte->classLoader = loader;
+ upcalls->OfChar->classLoader = loader;
+ upcalls->OfShort->classLoader = loader;
+ upcalls->OfInt->classLoader = loader;
+ upcalls->OfFloat->classLoader = loader;
+ upcalls->OfLong->classLoader = loader;
+ upcalls->OfDouble->classLoader = loader;
+
+ J3DenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
+ reinterpret_cast<J3DenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
+ loader->classes = new (loader->allocator, "ClassMap") ClassMap(precompiledClassMap);
+ for (ClassMap::iterator i = loader->getClasses()->map.begin(),
+ e = loader->getClasses()->map.end(); i != e; i++) {
+ vmjcAddPreCompiledClass(loader, i->second);
+ }
+
+ // Get the base object arrays after the init, because init puts arrays
+ // in the class loader map.
+ upcalls->ArrayOfString =
+ loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/String;"));
+
+ upcalls->ArrayOfObject =
+ loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/Object;"));
+
+ ClassArray::InterfacesArray = upcalls->ArrayOfObject->interfaces;
+
+ return true;
+}
+
}
Modified: vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Memory.cpp?rev=136592&r1=136591&r2=136592&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Memory.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Memory.cpp Sun Jul 31 05:54:50 2011
@@ -21,7 +21,7 @@
static const uintptr_t MemoryStart = 0x50000000;
#endif
-static const uintptr_t MemorySize = 0x40000000;
+static const uintptr_t MemorySize = 0x30000000;
class InitCollector {
public:
More information about the vmkit-commits
mailing list