[vmkit-commits] [vmkit] r54909 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMClass.cpp.inc Classpath/ClasspathVMThread.cpp.inc VMCore/JavaClass.cpp VMCore/JavaConstantPool.cpp VMCore/JavaInitialise.cpp VMCore/JavaIsolate.cpp VMCore/JavaIsolate.h VMCore/JavaJIT.cpp VMCore/JavaUpcalls.cpp VMCore/JavaUpcalls.h VMCore/Jnjvm.cpp VMCore/Jnjvm.h VMCore/JnjvmClassLoader.cpp VMCore/JnjvmClassLoader.h VMCore/VirtualTables.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Mon Aug 18 00:42:01 PDT 2008
Author: geoffray
Date: Mon Aug 18 02:41:59 2008
New Revision: 54909
URL: http://llvm.org/viewvc/llvm-project?rev=54909&view=rev
Log:
Remove JavaIsolate class, everything is in the Jnjvm class now.
Jnjvm now controls which exceptions are thrown internaly.
Simplify & comment.
Removed:
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
Modified:
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Mon Aug 18 02:41:59 2008
@@ -62,8 +62,7 @@
}
return (jclass)(cl->getClassDelegatee());
} else {
- JavaThread::get()->isolate->error(Jnjvm::ClassNotFoundException, "unable to load %s",
- ((JavaString*)str)->strToAsciiz());
+ JavaThread::get()->isolate->classNotFoundException((JavaString*)str);
return 0;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Mon Aug 18 02:41:59 2008
@@ -15,7 +15,6 @@
#include "JavaArray.h"
#include "JavaClass.h"
-#include "JavaIsolate.h"
#include "JavaJIT.h"
#include "JavaObject.h"
#include "JavaTypes.h"
@@ -59,7 +58,7 @@
#endif
CommonClass* vmthClass = vmThread->classOf;
JavaObject* thread = ClasspathThread::assocThread->getVirtualObjectField(vmThread);
- JavaIsolate* isolate = (JavaIsolate*)(intern->isolate);
+ Jnjvm* isolate = intern->isolate;
ThreadSystem* ts = isolate->threadSystem;
bool isDaemon = ClasspathThread::daemon->getVirtualInt8Field(thread);
intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Aug 18 02:41:59 2008
@@ -351,9 +351,7 @@
bool isStatic, bool recurse) {
JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse);
if (!res) {
- JavaThread::get()->isolate->error(Jnjvm::NoSuchMethodError,
- "unable to find %s in %s",
- name->printString(), this->printString());
+ JavaThread::get()->isolate->noSuchMethodError(this, name);
}
return res;
}
@@ -391,9 +389,7 @@
JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse);
if (!res) {
- JavaThread::get()->isolate->error(Jnjvm::NoSuchFieldError,
- "unable to find %s in %s",
- name->printString(), this->printString());
+ JavaThread::get()->isolate->noSuchFieldError(this, name);
}
return res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Aug 18 02:41:59 2008
@@ -45,7 +45,7 @@
static uint32 unimplemented(Class* cl, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"unknown constant pool type %d",
type);
return 1;
@@ -227,7 +227,7 @@
const UTF8* JavaCtpInfo::UTF8At(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantUTF8)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for utf8 at entry %d", entry);
}
return (const UTF8*)ctpRes[entry];
@@ -236,7 +236,7 @@
float JavaCtpInfo::FloatAt(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantFloat)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for float at entry %d", entry);
}
return ((float*)ctpDef)[entry];
@@ -245,7 +245,7 @@
sint32 JavaCtpInfo::IntegerAt(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantInteger)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for integer at entry %d", entry);
}
return ((sint32*)ctpDef)[entry];
@@ -254,7 +254,7 @@
sint64 JavaCtpInfo::LongAt(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantLong)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for long at entry %d", entry);
}
return Reader::readLong(ctpDef[entry], ctpDef[entry + 1]);
@@ -263,7 +263,7 @@
double JavaCtpInfo::DoubleAt(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantDouble)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for double at entry %d", entry);
}
return Reader::readDouble(ctpDef[entry], ctpDef[entry + 1]);
@@ -272,7 +272,7 @@
CommonClass* JavaCtpInfo::isLoadedClassOrClassName(uint32 entry) {
if (! ((entry > 0) && (entry < ctpSize) &&
typeAt(entry) == ConstantClass)) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for class at entry %d", entry);
}
return (CommonClass*)ctpRes[entry];
@@ -314,7 +314,7 @@
void JavaCtpInfo::checkInfoOfClass(uint32 index) {
if (typeAt(index) != ConstantClass)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for class at entry %d", index);
/*if (!(ctpRes[index]))
ctpRes[index] = JavaJIT::newLookupLLVM;*/
@@ -324,7 +324,7 @@
void* res = ctpRes[index];
if (!res) {
if (typeAt(index) != ConstantNameAndType) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for name/type at entry %d", index);
}
sint32 entry = ctpDef[index];
@@ -340,7 +340,7 @@
void* res = ctpRes[index];
if (!res) {
if (typeAt(index) != ConstantNameAndType) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for name/type at entry %d", index);
}
sint32 entry = ctpDef[index];
@@ -354,7 +354,7 @@
Typedef* JavaCtpInfo::infoOfField(uint32 index) {
if (typeAt(index) != ConstantFieldref)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for field at entry %d", index);
return resolveNameAndType(ctpDef[index] & 0xFFFF);
}
@@ -363,7 +363,7 @@
CommonClass*& cl, JavaMethod*& meth) {
uint8 id = typeAt(index);
if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for method at entry %d", index);
Signdef* sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
@@ -390,7 +390,7 @@
Signdef*& sign) {
uint8 id = typeAt(index);
if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for method at entry %d", index);
sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
@@ -406,7 +406,7 @@
JavaMethod*& meth) {
uint8 id = typeAt(index);
if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for method at entry %d", index);
sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
@@ -445,7 +445,7 @@
uint8 id = typeAt(index);
if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
+ JavaThread::get()->isolate->classFormatError(
"bad constant pool number for method at entry %d", index);
Signdef* sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Aug 18 02:41:59 2008
@@ -16,7 +16,6 @@
#include "JavaCache.h"
#include "JavaClass.h"
#include "JavaConstantPool.h"
-#include "JavaIsolate.h"
#include "JavaJIT.h"
#include "JavaObject.h"
#include "JavaString.h"
@@ -49,7 +48,6 @@
INIT(ClassMap);
INIT(StaticInstanceMap);
INIT(DelegateeMap);
- INIT(JavaIsolate);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
#ifdef SERVICE_VM
@@ -72,7 +70,8 @@
static void initialiseStatics() {
- JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader = JnjvmClassLoader::createBootstrapLoader();
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader =
+ JnjvmBootstrapLoader::createBootstrapLoader();
// Array initialization
const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
@@ -80,8 +79,7 @@
((UTF8*)utf8OfChar)->classOf = JavaArray::ofChar;
-
-
+
ClassArray::InterfacesArray.push_back(
JCL->constructClass(JCL->asciizConstructUTF8("java/lang/Cloneable")));
@@ -136,6 +134,8 @@
Jnjvm::postlib = JCL->asciizConstructUTF8(".so");
#endif
Jnjvm::mathName = JCL->asciizConstructUTF8("java/lang/Math");
+ Jnjvm::NoClassDefFoundError =
+ JCL->asciizConstructUTF8("java/lang/NoClassDefFoundError");
#define DEF_UTF8(var) \
Jnjvm::var = JCL->asciizConstructUTF8(#var)
@@ -182,8 +182,8 @@
}
void Jnjvm::runApplication(int argc, char** argv) {
- mvm::Thread::threadKey->set(((JavaIsolate*)this)->bootstrapThread);
- ((JavaIsolate*)this)->runMain(argc, argv);
+ mvm::Thread::threadKey->set(this->bootstrapThread);
+ this->runMain(argc, argv);
}
mvm::VirtualMachine* mvm::VirtualMachine::createJVM() {
@@ -191,7 +191,7 @@
ServiceDomain* vm = ServiceDomain::allocateService();
vm->startExecution();
#else
- JavaIsolate* vm = JavaIsolate::allocateIsolate();
+ Jnjvm* vm = Jnjvm::allocateIsolate();
#endif
return vm;
}
Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp?rev=54908&view=auto
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp (removed)
@@ -1,477 +0,0 @@
-//===------------ JavaIsolate.cpp - Start an isolate ----------------------===//
-//
-// JnJVM
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include <jni.h>
-
-#include "mvm/JIT.h"
-#include "mvm/MvmMemoryManager.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Cond.h"
-
-#include "JavaClass.h"
-#include "JavaIsolate.h"
-#include "JavaJIT.h"
-#include "JavaString.h"
-#include "JavaThread.h"
-#include "JavaTypes.h"
-#include "JavaUpcalls.h"
-#include "JnjvmModuleProvider.h"
-#include "LockedMap.h"
-#include "Reader.h"
-#include "Zip.h"
-
-#ifdef SERVICE_VM
-#include "ServiceDomain.h"
-#endif
-
-#define PATH_MANIFEST "META-INF/MANIFEST.MF"
-#define MAIN_CLASS "Main-Class: "
-#define PREMAIN_CLASS "Premain-Class: "
-#define BOOT_CLASS_PATH "Boot-Class-Path: "
-#define CAN_REDEFINE_CLASS_PATH "Can-Redefine-Classes: "
-
-#define LENGTH_MAIN_CLASS 12
-#define LENGTH_PREMAIN_CLASS 15
-#define LENGTH_BOOT_CLASS_PATH 17
-
-using namespace jnjvm;
-
-extern "C" struct JNINativeInterface JNI_JNIEnvTable;
-extern "C" const struct JNIInvokeInterface JNI_JavaVMTable;
-
-namespace jnjvm {
-
-class ClArgumentsInfo {
-public:
- uint32 appArgumentsPos;
- char* className;
- std::vector< std::pair<char*, char*> > agents;
-
- void readArgs(int argc, char** argv, Jnjvm *vm);
- void extractClassFromJar(Jnjvm* vm, int argc, char** argv, int i);
- void javaAgent(char* cur);
-
- void printInformation();
- void nyi();
- void printVersion();
-};
-
-}
-
-void ClArgumentsInfo::javaAgent(char* cur) {
- assert(0 && "implement me");
-}
-
-extern "C" int sys_strnstr(const char *haystack, const char *needle) {
- char * res = strstr(haystack, needle);
- if (res) return res - haystack;
- else return -1;
-}
-
-
-static char* findInformation(ArrayUInt8* manifest, const char* entry, uint32 len) {
- uint8* ptr = manifest->elements;
- sint32 index = sys_strnstr((char*)ptr, entry);
- if (index != -1) {
- index += len;
- sint32 end = sys_strnstr((char*)&(ptr[index]), "\n");
- if (end == -1) end = manifest->size;
- else end += index;
-
- sint32 length = end - index - 1;
- char* name = (char*)malloc(length + 1);
- memcpy(name, &(ptr[index]), length);
- name[length] = 0;
- return name;
- } else {
- return 0;
- }
-}
-
-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));
-
- sprintf(temp, "%s:%s", vm->classpath, jarFile);
- vm->setClasspath(temp);
-
- ArrayUInt8* bytes = Reader::openFile(JnjvmClassLoader::bootstrapLoader,
- jarFile);
-
- ZipArchive archive(bytes);
- if (archive.getOfscd() != -1) {
- ZipFile* file = archive.getFile(PATH_MANIFEST);
- if (file) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, &vm->allocator);
- int ok = archive.readFile(res, file);
- if (ok) {
- char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS);
- if (mainClass) {
- className = mainClass;
- } else {
- printf("No Main-Class: in Manifest of archive %s.\n", jarFile);
- }
- } else {
- printf("Can't extract Manifest file from archive %s\n", jarFile);
- }
- } else {
- printf("Can't find Manifest file in archive %s\n", jarFile);
- }
- } else {
- printf("Can't find archive %s\n", jarFile);
- }
-}
-
-void ClArgumentsInfo::nyi() {
- fprintf(stdout, "Not yet implemented\n");
-}
-
-void ClArgumentsInfo::printVersion() {
- fprintf(stdout, "JnJVM for Java 1.1 -- 1.5\n");
-}
-
-void ClArgumentsInfo::printInformation() {
- fprintf(stdout,
- "Usage: java [-options] class [args...] (to execute a class)\n"
- "or java [-options] -jar jarfile [args...]\n"
- "(to execute a jar file) where options include:\n"
- "-client to select the \"client\" VM\n"
- "-server to select the \"server\" VM\n"
- "-hotspot is a synonym for the \"client\" VM [deprecated]\n"
- " The default VM is client.\n"
- "\n"
- "-cp <class search path of directories and zip/jar files>\n"
- "-classpath <class search path of directories and zip/jar files>\n"
- " A : separated list of directories, JAR archives,\n"
- " and ZIP archives to search for class files.\n"
- "-D<name>=<value>\n"
- " set a system property\n"
- "-verbose[:class|gc|jni]\n"
- " enable verbose output\n"
- "-version print product version and exit\n"
- "-version:<value>\n"
- " require the specified version to run\n"
- "-showversion print product version and continue\n"
- "-jre-restrict-search | -jre-no-restrict-search\n"
- " include/exclude user private JREs in the version search\n"
- "-? -help print this help message\n"
- "-X print help on non-standard options\n"
- "-ea[:<packagename>...|:<classname>]\n"
- "-enableassertions[:<packagename>...|:<classname>]\n"
- " enable assertions\n"
- "-da[:<packagename>...|:<classname>]\n"
- "-disableassertions[:<packagename>...|:<classname>]\n"
- " disable assertions\n"
- "-esa | -enablesystemassertions\n"
- " enable system assertions\n"
- "-dsa | -disablesystemassertions\n"
- " disable system assertions\n"
- "-agentlib:<libname>[=<options>]\n"
- " load native agent library <libname>, e.g. -agentlib:hprof\n"
- " see also, -agentlib:jdwp=help and -agentlib:hprof=help\n"
- "-agentpath:<pathname>[=<options>]\n"
- " load native agent library by full pathname\n"
- "-javaagent:<jarpath>[=<options>]\n"
- " load Java programming language agent, see java.lang.instrument\n");
-}
-
-void ClArgumentsInfo::readArgs(int argc, char** argv, Jnjvm* vm) {
- className = 0;
- appArgumentsPos = 0;
- sint32 i = 1;
- if (i == argc) printInformation();
- while (i < argc) {
- char* cur = argv[i];
- if (!(strcmp(cur, "-client"))) {
- nyi();
- } else if (!(strcmp(cur, "-server"))) {
- nyi();
- } else if (!(strcmp(cur, "-classpath"))) {
- ++i;
- if (i == argc) printInformation();
- else vm->setClasspath(argv[i]);
- } else if (!(strcmp(cur, "-cp"))) {
- ++i;
- if (i == argc) printInformation();
- else vm->setClasspath(argv[i]);
- } else if (!(strcmp(cur, "-debug"))) {
- nyi();
- } else if (!(strncmp(cur, "-D", 2))) {
- uint32 len = strlen(cur);
- if (len == 2) {
- printInformation();
- } else {
- char* key = &cur[2];
- char* value = strchr(key, '=');
- if (!value) {
- printInformation();
- return;
- } else {
- value[0] = 0;
- vm->addProperty(key, &value[1]);
- }
- }
- } else if (!(strncmp(cur, "-Xbootclasspath:", 16))) {
- uint32 len = strlen(cur);
- if (len == 16) {
- printInformation();
- } else {
- char* path = &cur[16];
- JnjvmClassLoader::bootstrapLoader->analyseClasspathEnv(path);
- }
- } else if (!(strcmp(cur, "-enableassertions"))) {
- nyi();
- } else if (!(strcmp(cur, "-ea"))) {
- nyi();
- } else if (!(strcmp(cur, "-disableassertions"))) {
- nyi();
- } else if (!(strcmp(cur, "-da"))) {
- nyi();
- } else if (!(strcmp(cur, "-enablesystemassertions"))) {
- nyi();
- } else if (!(strcmp(cur, "-esa"))) {
- nyi();
- } else if (!(strcmp(cur, "-disablesystemassertions"))) {
- nyi();
- } else if (!(strcmp(cur, "-dsa"))) {
- nyi();
- } else if (!(strcmp(cur, "-jar"))) {
- ++i;
- if (i == argc) {
- printInformation();
- } else {
- extractClassFromJar(vm, argc, argv, i);
- appArgumentsPos = i;
- return;
- }
- } else if (!(strcmp(cur, "-jre-restrict-research"))) {
- nyi();
- } else if (!(strcmp(cur, "-jre-no-restrict-research"))) {
- nyi();
- } else if (!(strcmp(cur, "-noclassgc"))) {
- nyi();
- } else if (!(strcmp(cur, "-ms"))) {
- nyi();
- } else if (!(strcmp(cur, "-mx"))) {
- nyi();
- } else if (!(strcmp(cur, "-ss"))) {
- nyi();
- } else if (!(strcmp(cur, "-verbose"))) {
- nyi();
- } else if (!(strcmp(cur, "-verbose:class"))) {
- nyi();
- } else if (!(strcmp(cur, "-verbosegc"))) {
- nyi();
- } else if (!(strcmp(cur, "-verbose:gc"))) {
- nyi();
- } else if (!(strcmp(cur, "-verbose:jni"))) {
- nyi();
- } else if (!(strcmp(cur, "-version"))) {
- printVersion();
- } else if (!(strcmp(cur, "-showversion"))) {
- nyi();
- } else if (!(strcmp(cur, "-?"))) {
- printInformation();
- } else if (!(strcmp(cur, "-help"))) {
- printInformation();
- } else if (!(strcmp(cur, "-X"))) {
- nyi();
- } else if (!(strcmp(cur, "-agentlib"))) {
- nyi();
- } else if (!(strcmp(cur, "-agentpath"))) {
- nyi();
- } else if (cur[0] == '-') {
- } else if (!(strcmp(cur, "-javaagent"))) {
- javaAgent(cur);
- } else {
- className = cur;
- appArgumentsPos = i;
- return;
- }
- ++i;
- }
-}
-
-
-void JavaIsolate::print(mvm::PrintBuffer* buf) const {
- buf->write("Java isolate: ");
- buf->write(name);
-
-}
-
-JnjvmClassLoader* JavaIsolate::loadAppClassLoader() {
- if (appClassLoader == 0) {
- JavaObject* loader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this);
- appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader);
- }
- return appClassLoader;
-}
-
-void JavaIsolate::mapInitialThread() {
- ClasspathThread::mapInitialThread(this);
-}
-
-void JavaIsolate::loadBootstrap() {
- JnjvmClassLoader* loader = JnjvmClassLoader::bootstrapLoader;
- loader->loadName(Classpath::newVMThrowable->name,
- true, true, true);
- loader->loadName(Classpath::newClass->name,
- true, true, true);
- loader->loadName(Classpath::newConstructor->name,
- true, true, true);
- loader->loadName(Classpath::newMethod->name,
- true, true, true);
- loader->loadName(Classpath::newField->name,
- true, true, true);
- loader->loadName(Classpath::newStackTraceElement->name,
- true, true, true);
- mapInitialThread();
- loadAppClassLoader();
- JavaObject* obj = JavaThread::currentThread();
- Classpath::setContextClassLoader->invokeIntSpecial(this, obj, appClassLoader->getJavaClassLoader());
- // load and initialise math since it is responsible for dlopen'ing
- // libjavalang.so and we are optimizing some math operations
- loader->loadName(loader->asciizConstructUTF8("java/lang/Math"),
- true, true, true);
-}
-
-void JavaIsolate::executeClass(const char* className, ArrayObject* args) {
- try {
- JavaJIT::invokeOnceVoid(this, appClassLoader, className, "main",
- "([Ljava/lang/String;)V", ACC_STATIC, args);
- }catch(...) {
- }
-
- JavaObject* exc = JavaThread::get()->pendingException;
- if (exc) {
- JavaThread::clearException();
- JavaObject* obj = JavaThread::currentThread();
- JavaObject* group =
- ClasspathThread::group->getVirtualObjectField(obj);
- try{
- ClasspathThread::uncaughtException->invokeIntSpecial(this, group, obj,
- exc);
- }catch(...) {
- printf("Even uncaught exception throwed an exception!\n");
- assert(0);
- }
- }
-}
-
-void JavaIsolate::executePremain(const char* className, JavaString* args,
- JavaObject* instrumenter) {
- JavaJIT::invokeOnceVoid(this, appClassLoader, className, "premain",
- "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V",
- ACC_STATIC, args, instrumenter);
-}
-
-void JavaIsolate::waitForExit() {
- threadSystem->nonDaemonLock->lock();
- --(threadSystem->nonDaemonThreads);
-
- while (threadSystem->nonDaemonThreads) {
- threadSystem->nonDaemonVar->wait(threadSystem->nonDaemonLock);
- }
-
- threadSystem->nonDaemonLock->unlock();
- return;
-}
-
-void JavaIsolate::runMain(int argc, char** argv) {
- ClArgumentsInfo info;
-
- info.readArgs(argc, argv, this);
- if (info.className) {
- int pos = info.appArgumentsPos;
- //llvm::cl::ParseCommandLineOptions(pos, argv,
- // " JnJVM Java Virtual Machine\n");
- argv = argv + pos - 1;
- argc = argc - pos + 1;
-
- loadBootstrap();
-#ifdef SERVICE_VM
- ServiceDomain::initialise((ServiceDomain*)this);
-#endif
-
- if (info.agents.size()) {
- assert(0 && "implement me");
- JavaObject* instrumenter = 0;//createInstrumenter();
- for (std::vector< std::pair<char*, char*> >::iterator i = info.agents.begin(),
- e = info.agents.end(); i!= e; ++i) {
- JavaString* args = asciizToStr(i->second);
- executePremain(i->first, args, instrumenter);
- }
- }
-
- ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString, &allocator);
- for (int i = 2; i < argc; ++i) {
- args->elements[i - 2] = (JavaObject*)asciizToStr(argv[i]);
- }
-
- executeClass(info.className, args);
- waitForExit();
- }
-}
-
-void JavaIsolate::runIsolate(const char* className, ArrayObject* args) {
- JavaIsolate *isolate = allocateIsolate();
- isolate->loadBootstrap();
- isolate->executeClass(className, args);
- isolate->waitForExit();
-}
-
-JavaIsolate* JavaIsolate::allocateIsolate() {
- JavaIsolate *isolate= gc_new(JavaIsolate)();
-
-#ifdef MULTIPLE_GC
- isolate->GC = Collector::allocate();
-#endif
- isolate->classpath = getenv("CLASSPATH");
- if (!(isolate->classpath)) {
- isolate->classpath = ".";
- }
-
- isolate->bootstrapThread = gc_new(JavaThread)();
- isolate->bootstrapThread->initialise(0, isolate);
- void* baseSP = mvm::Thread::get()->baseSP;
- isolate->bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
-
-#ifdef MULTIPLE_GC
- isolate->bootstrapThread->GC = isolate->GC;
- isolate->GC->inject_my_thread(baseSP);
-#endif
- isolate->bootstrapThread->baseSP = baseSP;
- JavaThread::threadKey->set(isolate->bootstrapThread);
-
- isolate->threadSystem = new ThreadSystem();
- 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->hashStr = new StringMap();
- isolate->globalRefsLock = mvm::Lock::allocNormal();
-#ifdef MULTIPLE_VM
- isolate->statics = vm_new(isolate, StaticInstanceMap)();
- isolate->delegatees = vm_new(isolate, DelegateeMap)();
-#endif
-
- return isolate;
-}
-
-JavaIsolate::~JavaIsolate() {
- delete threadSystem;
-}
-
-JavaIsolate::JavaIsolate() {
- threadSystem = 0;
-}
Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h?rev=54908&view=auto
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h (removed)
@@ -1,74 +0,0 @@
-//===---------------- JavaIsolate.h - Isolates ----------------------------===//
-//
-// JnJVM
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef JNJVM_JAVA_ISOLATE_H
-#define JNJVM_JAVA_ISOLATE_H
-
-
-#include "mvm/Object.h"
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-
-#include "types.h"
-
-#include "Jnjvm.h"
-
-namespace jnjvm {
-
-class ArrayObject;
-class JavaThread;
-class JavaObject;
-class ThreadSystem;
-
-class ThreadSystem {
-public:
- uint16 nonDaemonThreads;
- mvm::Lock* nonDaemonLock;
- mvm::Cond* nonDaemonVar;
-
- ThreadSystem() {
- nonDaemonThreads = 1;
- nonDaemonLock = mvm::Lock::allocNormal();
- nonDaemonVar = mvm::Cond::allocCond();
- }
-
- ~ThreadSystem() {
- delete nonDaemonLock;
- delete nonDaemonVar;
- }
-
-};
-
-class JavaIsolate : public Jnjvm {
-public:
- static VirtualTable* VT;
- ThreadSystem* threadSystem;
- JavaThread* bootstrapThread;
-
- virtual void print(mvm::PrintBuffer* buf) const;
- virtual void TRACER;
- ~JavaIsolate();
- JavaIsolate();
-
- JnjvmClassLoader* loadAppClassLoader();
- void loadBootstrap();
- void executeClass(const char* className, ArrayObject* args);
- void executePremain(const char* className, JavaString* args,
- JavaObject* instrumenter);
- void waitForExit();
- void runMain(int argc, char** argv);
- void mapInitialThread();
- static void runIsolate(const char* className, ArrayObject* args);
- static JavaIsolate* allocateIsolate();
-
-};
-
-} // end namespace jnjvm
-
-#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Aug 18 02:41:59 2008
@@ -929,7 +929,7 @@
if (exc) {
Jnjvm* vm = JavaThread::get()->isolate;
- vm->errorWithExcp(Jnjvm::NoClassDefFoundError, exc);
+ vm->noClassDefFoundError(exc);
}
ex->catchClass = cl;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Mon Aug 18 02:41:59 2008
@@ -111,6 +111,72 @@
Class* Classpath::vmStackWalker;
+Class* ClasspathException::InvocationTargetException;
+Class* ClasspathException::ArrayStoreException;
+Class* ClasspathException::ClassCastException;
+Class* ClasspathException::IllegalMonitorStateException;
+Class* ClasspathException::IllegalArgumentException;
+Class* ClasspathException::InterruptedException;
+Class* ClasspathException::IndexOutOfBoundsException;
+Class* ClasspathException::ArrayIndexOutOfBoundsException;
+Class* ClasspathException::NegativeArraySizeException;
+Class* ClasspathException::NullPointerException;
+Class* ClasspathException::SecurityException;
+Class* ClasspathException::ClassFormatError;
+Class* ClasspathException::ClassCircularityError;
+Class* ClasspathException::NoClassDefFoundError;
+Class* ClasspathException::UnsupportedClassVersionError;
+Class* ClasspathException::NoSuchFieldError;
+Class* ClasspathException::NoSuchMethodError;
+Class* ClasspathException::InstantiationError;
+Class* ClasspathException::IllegalAccessError;
+Class* ClasspathException::IllegalAccessException;
+Class* ClasspathException::VerifyError;
+Class* ClasspathException::ExceptionInInitializerError;
+Class* ClasspathException::LinkageError;
+Class* ClasspathException::AbstractMethodError;
+Class* ClasspathException::UnsatisfiedLinkError;
+Class* ClasspathException::InternalError;
+Class* ClasspathException::OutOfMemoryError;
+Class* ClasspathException::StackOverflowError;
+Class* ClasspathException::UnknownError;
+Class* ClasspathException::ClassNotFoundException;
+
+JavaMethod* ClasspathException::InitInvocationTargetException;
+JavaMethod* ClasspathException::InitArrayStoreException;
+JavaMethod* ClasspathException::InitClassCastException;
+JavaMethod* ClasspathException::InitIllegalMonitorStateException;
+JavaMethod* ClasspathException::InitIllegalArgumentException;
+JavaMethod* ClasspathException::InitInterruptedException;
+JavaMethod* ClasspathException::InitIndexOutOfBoundsException;
+JavaMethod* ClasspathException::InitArrayIndexOutOfBoundsException;
+JavaMethod* ClasspathException::InitNegativeArraySizeException;
+JavaMethod* ClasspathException::InitNullPointerException;
+JavaMethod* ClasspathException::InitSecurityException;
+JavaMethod* ClasspathException::InitClassFormatError;
+JavaMethod* ClasspathException::InitClassCircularityError;
+JavaMethod* ClasspathException::InitNoClassDefFoundError;
+JavaMethod* ClasspathException::InitUnsupportedClassVersionError;
+JavaMethod* ClasspathException::InitNoSuchFieldError;
+JavaMethod* ClasspathException::InitNoSuchMethodError;
+JavaMethod* ClasspathException::InitInstantiationError;
+JavaMethod* ClasspathException::InitIllegalAccessError;
+JavaMethod* ClasspathException::InitIllegalAccessException;
+JavaMethod* ClasspathException::InitVerifyError;
+JavaMethod* ClasspathException::InitExceptionInInitializerError;
+JavaMethod* ClasspathException::InitLinkageError;
+JavaMethod* ClasspathException::InitAbstractMethodError;
+JavaMethod* ClasspathException::InitUnsatisfiedLinkError;
+JavaMethod* ClasspathException::InitInternalError;
+JavaMethod* ClasspathException::InitOutOfMemoryError;
+JavaMethod* ClasspathException::InitStackOverflowError;
+JavaMethod* ClasspathException::InitUnknownError;
+JavaMethod* ClasspathException::InitClassNotFoundException;
+
+JavaMethod* ClasspathException::ErrorWithExcpNoClassDefFoundError;
+JavaMethod* ClasspathException::ErrorWithExcpExceptionInInitializerError;
+JavaMethod* ClasspathException::ErrorWithExcpInvocationTargetException;
+
void ClasspathThread::initialise(JnjvmClassLoader* vm) {
newThread =
UPCALL_CLASS(vm, "java/lang/Thread");
@@ -168,6 +234,75 @@
"(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);
}
+void ClasspathException::initialise(JnjvmClassLoader* loader) {
+ UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);
+ UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);
+ UPCALL_CLASS_EXCEPTION(loader, ClassCastException);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);
+ UPCALL_CLASS_EXCEPTION(loader, InterruptedException);
+ UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);
+ UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
+ UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);
+ UPCALL_CLASS_EXCEPTION(loader, NullPointerException);
+ UPCALL_CLASS_EXCEPTION(loader, SecurityException);
+ UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);
+ UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);
+ UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);
+ UPCALL_CLASS_EXCEPTION(loader, InstantiationError);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);
+ UPCALL_CLASS_EXCEPTION(loader, VerifyError);
+ UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_CLASS_EXCEPTION(loader, LinkageError);
+ UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);
+ UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);
+ UPCALL_CLASS_EXCEPTION(loader, InternalError);
+ UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);
+ UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);
+ UPCALL_CLASS_EXCEPTION(loader, UnknownError);
+ UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);
+
+ UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);
+ UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);
+ UPCALL_METHOD_EXCEPTION(loader, ClassCastException);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);
+ UPCALL_METHOD_EXCEPTION(loader, InterruptedException);
+ UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);
+ UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
+ UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);
+ UPCALL_METHOD_EXCEPTION(loader, NullPointerException);
+ UPCALL_METHOD_EXCEPTION(loader, SecurityException);
+ UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);
+ UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);
+ UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);
+ UPCALL_METHOD_EXCEPTION(loader, InstantiationError);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);
+ UPCALL_METHOD_EXCEPTION(loader, VerifyError);
+ UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_METHOD_EXCEPTION(loader, LinkageError);
+ UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);
+ UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);
+ UPCALL_METHOD_EXCEPTION(loader, InternalError);
+ UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);
+ UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);
+ UPCALL_METHOD_EXCEPTION(loader, UnknownError);
+ UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);
+
+ UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
+}
+
+
void ClasspathThread::createInitialThread(Jnjvm* vm, JavaObject* th) {
JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
JCL->loadName(newVMThread->name, true, true, true);
@@ -387,6 +522,7 @@
vm->TheModule->setMethod(isArray, "isArray");
ClasspathThread::initialise(vm);
+ ClasspathException::initialise(vm);
vm->loadName(vm->asciizConstructUTF8("java/lang/String"),
true, false, false);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Mon Aug 18 02:41:59 2008
@@ -11,11 +11,11 @@
#define JNJVM_JAVA_UPCALLS_H
-#define UPCALL_CLASS(vm, name) \
- vm->constructClass(vm->asciizConstructUTF8(name)) \
+#define UPCALL_CLASS(vm, name) \
+ vm->constructClass(vm->asciizConstructUTF8(name))
-#define UPCALL_FIELD(vm, cl, name, type, acc) \
- UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \
+#define UPCALL_FIELD(vm, cl, name, type, acc) \
+ UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \
vm->asciizConstructUTF8(type), acc)
#define UPCALL_METHOD(vm, cl, name, type, acc) \
@@ -25,8 +25,23 @@
#define UPCALL_ARRAY_CLASS(vm, name, depth) \
vm->constructArray( \
AssessorDesc::constructArrayName(vm, 0, depth, \
- vm->asciizConstructUTF8(name))) \
+ vm->asciizConstructUTF8(name)))
+#define UPCALL_CLASS_EXCEPTION(loader, name) \
+ name = UPCALL_CLASS(loader, "java/lang/"#name)
+
+#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name) \
+ name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)
+
+#define UPCALL_METHOD_EXCEPTION(loader, name) \
+ Init##name = name->constructMethod(loader->asciizConstructUTF8("<init>"), \
+ loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \
+ ACC_VIRTUAL);
+
+#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \
+ ErrorWithExcp##name = name->constructMethod(loader->asciizConstructUTF8("<init>"), \
+ loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \
+ ACC_VIRTUAL);
namespace jnjvm {
@@ -60,6 +75,77 @@
static void mapInitialThread(Jnjvm* vm);
};
+class ClasspathException {
+public:
+ static void initialise(JnjvmClassLoader* vm);
+
+ static Class* InvocationTargetException;
+ static Class* ArrayStoreException;
+ static Class* ClassCastException;
+ static Class* IllegalMonitorStateException;
+ static Class* IllegalArgumentException;
+ static Class* InterruptedException;
+ static Class* IndexOutOfBoundsException;
+ static Class* ArrayIndexOutOfBoundsException;
+ static Class* NegativeArraySizeException;
+ static Class* NullPointerException;
+ static Class* SecurityException;
+ static Class* ClassFormatError;
+ static Class* ClassCircularityError;
+ static Class* NoClassDefFoundError;
+ static Class* UnsupportedClassVersionError;
+ static Class* NoSuchFieldError;
+ static Class* NoSuchMethodError;
+ static Class* InstantiationError;
+ static Class* IllegalAccessError;
+ static Class* IllegalAccessException;
+ static Class* VerifyError;
+ static Class* ExceptionInInitializerError;
+ static Class* LinkageError;
+ static Class* AbstractMethodError;
+ static Class* UnsatisfiedLinkError;
+ static Class* InternalError;
+ static Class* OutOfMemoryError;
+ static Class* StackOverflowError;
+ static Class* UnknownError;
+ static Class* ClassNotFoundException;
+
+ static JavaMethod* InitInvocationTargetException;
+ static JavaMethod* InitArrayStoreException;
+ static JavaMethod* InitClassCastException;
+ static JavaMethod* InitIllegalMonitorStateException;
+ static JavaMethod* InitIllegalArgumentException;
+ static JavaMethod* InitInterruptedException;
+ static JavaMethod* InitIndexOutOfBoundsException;
+ static JavaMethod* InitArrayIndexOutOfBoundsException;
+ static JavaMethod* InitNegativeArraySizeException;
+ static JavaMethod* InitNullPointerException;
+ static JavaMethod* InitSecurityException;
+ static JavaMethod* InitClassFormatError;
+ static JavaMethod* InitClassCircularityError;
+ static JavaMethod* InitNoClassDefFoundError;
+ static JavaMethod* InitUnsupportedClassVersionError;
+ static JavaMethod* InitNoSuchFieldError;
+ static JavaMethod* InitNoSuchMethodError;
+ static JavaMethod* InitInstantiationError;
+ static JavaMethod* InitIllegalAccessError;
+ static JavaMethod* InitIllegalAccessException;
+ static JavaMethod* InitVerifyError;
+ static JavaMethod* InitExceptionInInitializerError;
+ static JavaMethod* InitLinkageError;
+ static JavaMethod* InitAbstractMethodError;
+ static JavaMethod* InitUnsatisfiedLinkError;
+ static JavaMethod* InitInternalError;
+ static JavaMethod* InitOutOfMemoryError;
+ static JavaMethod* InitStackOverflowError;
+ static JavaMethod* InitUnknownError;
+ static JavaMethod* InitClassNotFoundException;
+
+ static JavaMethod* ErrorWithExcpNoClassDefFoundError;
+ static JavaMethod* ErrorWithExcpExceptionInInitializerError;
+ static JavaMethod* ErrorWithExcpInvocationTargetException;
+};
+
class Classpath {
public:
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=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Aug 18 02:41:59 2008
@@ -41,6 +41,7 @@
#define DEF_UTF8(var) \
const UTF8* Jnjvm::var = 0
+ DEF_UTF8(NoClassDefFoundError);
DEF_UTF8(initName);
DEF_UTF8(clinitName);
DEF_UTF8(clinitType);
@@ -79,44 +80,6 @@
const char* Jnjvm::envSeparator = ":";
const unsigned int Jnjvm::Magic = 0xcafebabe;
-#define DECLARE_EXCEPTION(EXCP) \
- const char* Jnjvm::EXCP = "java/lang/"#EXCP
-
-#define DECLARE_REFLECT_EXCEPTION(EXCP) \
- const char* Jnjvm::EXCP = "java/lang/reflect/"#EXCP
-
-DECLARE_EXCEPTION(ArithmeticException);
-DECLARE_REFLECT_EXCEPTION(InvocationTargetException);
-DECLARE_EXCEPTION(ArrayStoreException);
-DECLARE_EXCEPTION(ClassCastException);
-DECLARE_EXCEPTION(IllegalMonitorStateException);
-DECLARE_EXCEPTION(IllegalArgumentException);
-DECLARE_EXCEPTION(InterruptedException);
-DECLARE_EXCEPTION(IndexOutOfBoundsException);
-DECLARE_EXCEPTION(ArrayIndexOutOfBoundsException);
-DECLARE_EXCEPTION(NegativeArraySizeException);
-DECLARE_EXCEPTION(NullPointerException);
-DECLARE_EXCEPTION(SecurityException);
-DECLARE_EXCEPTION(ClassFormatError);
-DECLARE_EXCEPTION(ClassCircularityError);
-DECLARE_EXCEPTION(NoClassDefFoundError);
-DECLARE_EXCEPTION(UnsupportedClassVersionError);
-DECLARE_EXCEPTION(NoSuchFieldError);
-DECLARE_EXCEPTION(NoSuchMethodError);
-DECLARE_EXCEPTION(InstantiationError);
-DECLARE_EXCEPTION(IllegalAccessError);
-DECLARE_EXCEPTION(IllegalAccessException);
-DECLARE_EXCEPTION(VerifyError);
-DECLARE_EXCEPTION(ExceptionInInitializerError);
-DECLARE_EXCEPTION(LinkageError);
-DECLARE_EXCEPTION(AbstractMethodError);
-DECLARE_EXCEPTION(UnsatisfiedLinkError);
-DECLARE_EXCEPTION(InternalError);
-DECLARE_EXCEPTION(OutOfMemoryError);
-DECLARE_EXCEPTION(StackOverflowError);
-DECLARE_EXCEPTION(UnknownError);
-DECLARE_EXCEPTION(ClassNotFoundException);
-
typedef void (*clinit_t)(Jnjvm* vm);
void Jnjvm::initialiseClass(CommonClass* cl) {
@@ -185,59 +148,37 @@
}
-void Jnjvm::errorWithExcp(const char* className, const JavaObject* excp) {
- JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
- Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
- true, true, true);
+void Jnjvm::errorWithExcp(Class* cl, JavaMethod* init, const JavaObject* excp) {
JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
- "(Ljava/lang/Throwable;)V", ACC_VIRTUAL, obj, excp);
+ init->invokeIntSpecial(this, obj, excp);
JavaThread::throwException(obj);
}
-void Jnjvm::error(const char* className, const char* fmt, ...) {
- JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+void Jnjvm::error(Class* cl, JavaMethod* init, const char* fmt, ...) {
char* tmp = (char*)alloca(4096);
- Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
- true, true, true);
va_list ap;
va_start(ap, fmt);
vsnprintf(tmp, 4096, fmt, ap);
va_end(ap);
-
- JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
- "(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
- this->asciizToStr(tmp));
- JavaThread::throwException(obj);
-}
-
-
-void Jnjvm::verror(const char* className, const char* fmt, va_list ap) {
- JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
- char* tmp = (char*)alloca(4096);
- Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
- true, true, true);
- vsnprintf(tmp, 4096, fmt, ap);
- va_end(ap);
+
JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
- "(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
- this->asciizToStr(tmp));
-
+ init->invokeIntSpecial(this, obj, asciizToStr(tmp));
JavaThread::throwException(obj);
}
void Jnjvm::arrayStoreException() {
- error(ArrayStoreException, "");
+ error(ClasspathException::ArrayStoreException,
+ ClasspathException::InitArrayStoreException, "");
}
void Jnjvm::indexOutOfBounds(const JavaObject* obj, sint32 entry) {
- error(ArrayIndexOutOfBoundsException, "%d", entry);
+ error(ClasspathException::ArrayIndexOutOfBoundsException,
+ ClasspathException::InitArrayIndexOutOfBoundsException, "%d", entry);
}
void Jnjvm::negativeArraySizeException(sint32 size) {
- error(NegativeArraySizeException, "%d", size);
+ error(ClasspathException::NegativeArraySizeException,
+ ClasspathException::InitNegativeArraySizeException, "%d", size);
}
void Jnjvm::nullPointerException(const char* fmt, ...) {
@@ -245,58 +186,116 @@
va_start(ap, fmt);
char* val = va_arg(ap, char*);
va_end(ap);
- error(NullPointerException, fmt, val);
+ error(ClasspathException::NullPointerException,
+ ClasspathException::InitNullPointerException, fmt, val);
}
void Jnjvm::illegalAccessException(const char* msg) {
- error(IllegalAccessException, msg);
+ error(ClasspathException::IllegalAccessException,
+ ClasspathException::InitIllegalAccessException, msg);
}
void Jnjvm::illegalMonitorStateException(const JavaObject* obj) {
- error(IllegalMonitorStateException, "");
+ error(ClasspathException::IllegalMonitorStateException,
+ ClasspathException::InitIllegalMonitorStateException, "");
}
void Jnjvm::interruptedException(const JavaObject* obj) {
- error(InterruptedException, "");
+ error(ClasspathException::InterruptedException,
+ ClasspathException::InitInterruptedException, "");
}
void Jnjvm::initializerError(const JavaObject* excp) {
- errorWithExcp(ExceptionInInitializerError, excp);
+ errorWithExcp(ClasspathException::ExceptionInInitializerError,
+ ClasspathException::ErrorWithExcpExceptionInInitializerError,
+ excp);
}
void Jnjvm::invocationTargetException(const JavaObject* excp) {
- errorWithExcp(InvocationTargetException, excp);
+ errorWithExcp(ClasspathException::InvocationTargetException,
+ ClasspathException::ErrorWithExcpInvocationTargetException,
+ excp);
}
void Jnjvm::outOfMemoryError(sint32 n) {
- error(OutOfMemoryError, "");
+ error(ClasspathException::OutOfMemoryError,
+ ClasspathException::InitOutOfMemoryError, "%d", n);
}
void Jnjvm::illegalArgumentExceptionForMethod(JavaMethod* meth,
CommonClass* required,
CommonClass* given) {
- error(IllegalArgumentException, "for method %s", meth->printString());
+ error(ClasspathException::IllegalArgumentException,
+ ClasspathException::InitIllegalArgumentException,
+ "for method %s", meth->printString());
}
void Jnjvm::illegalArgumentExceptionForField(JavaField* field,
CommonClass* required,
CommonClass* given) {
- error(IllegalArgumentException, "for field %s", field->printString());
+ error(ClasspathException::IllegalArgumentException,
+ ClasspathException::InitIllegalArgumentException,
+ "for field %s", field->printString());
}
void Jnjvm::illegalArgumentException(const char* msg) {
- error(IllegalArgumentException, msg);
+ error(ClasspathException::IllegalArgumentException,
+ ClasspathException::InitIllegalArgumentException,
+ msg);
}
void Jnjvm::classCastException(const char* msg) {
- error(ClassCastException, msg);
+ error(ClasspathException::ClassCastException,
+ ClasspathException::InitClassCastException,
+ msg);
+}
+
+void Jnjvm::noSuchFieldError(CommonClass* cl, const UTF8* name) {
+ error(ClasspathException::NoSuchFieldError,
+ ClasspathException::InitNoSuchFieldError,
+ "unable to find %s in %s",
+ name->printString(), cl->printString());
+
+}
+
+void Jnjvm::noSuchMethodError(CommonClass* cl, const UTF8* name) {
+ error(ClasspathException::NoSuchMethodError,
+ ClasspathException::InitNoSuchMethodError,
+ "unable to find %s in %s",
+ name->printString(), cl->printString());
+
+}
+
+void Jnjvm::classFormatError(const char* msg, ...) {
+ error(ClasspathException::ClassFormatError,
+ ClasspathException::InitClassFormatError,
+ msg);
+}
+
+void Jnjvm::noClassDefFoundError(JavaObject* obj) {
+ errorWithExcp(ClasspathException::NoClassDefFoundError,
+ ClasspathException::ErrorWithExcpNoClassDefFoundError,
+ obj);
+}
+
+void Jnjvm::noClassDefFoundError(const char* fmt, ...) {
+ error(ClasspathException::NoClassDefFoundError,
+ ClasspathException::InitNoClassDefFoundError,
+ fmt);
+}
+
+void Jnjvm::classNotFoundException(JavaString* str) {
+ error(ClasspathException::ClassNotFoundException,
+ ClasspathException::InitClassNotFoundException,
+ "unable to load %s",
+ str->strToAsciiz());
}
void Jnjvm::unknownError(const char* fmt, ...) {
- va_list ap;
- va_start(ap, fmt);
- verror(UnknownError, fmt, ap);
+ error(ClasspathException::UnknownError,
+ ClasspathException::InitUnknownError,
+ fmt);
}
JavaString* Jnjvm::UTF8ToStr(const UTF8* utf8) {
@@ -362,6 +361,7 @@
delete hashStr;
delete globalRefsLock;
+ delete threadSystem;
}
Jnjvm::Jnjvm() {
@@ -370,4 +370,470 @@
#endif
hashStr = 0;
globalRefsLock = 0;
+ threadSystem = 0;
+}
+
+#define PATH_MANIFEST "META-INF/MANIFEST.MF"
+#define MAIN_CLASS "Main-Class: "
+#define PREMAIN_CLASS "Premain-Class: "
+#define BOOT_CLASS_PATH "Boot-Class-Path: "
+#define CAN_REDEFINE_CLASS_PATH "Can-Redefine-Classes: "
+
+#define LENGTH_MAIN_CLASS 12
+#define LENGTH_PREMAIN_CLASS 15
+#define LENGTH_BOOT_CLASS_PATH 17
+
+extern "C" struct JNINativeInterface JNI_JNIEnvTable;
+extern "C" const struct JNIInvokeInterface JNI_JavaVMTable;
+
+namespace jnjvm {
+
+class ClArgumentsInfo {
+public:
+ uint32 appArgumentsPos;
+ char* className;
+ std::vector< std::pair<char*, char*> > agents;
+
+ void readArgs(int argc, char** argv, Jnjvm *vm);
+ void extractClassFromJar(Jnjvm* vm, int argc, char** argv, int i);
+ void javaAgent(char* cur);
+
+ void printInformation();
+ void nyi();
+ void printVersion();
+};
+
+}
+
+void ClArgumentsInfo::javaAgent(char* cur) {
+ assert(0 && "implement me");
+}
+
+extern "C" int sys_strnstr(const char *haystack, const char *needle) {
+ char * res = strstr(haystack, needle);
+ if (res) return res - haystack;
+ else return -1;
+}
+
+
+static char* findInformation(ArrayUInt8* manifest, const char* entry, uint32 len) {
+ uint8* ptr = manifest->elements;
+ sint32 index = sys_strnstr((char*)ptr, entry);
+ if (index != -1) {
+ index += len;
+ sint32 end = sys_strnstr((char*)&(ptr[index]), "\n");
+ if (end == -1) end = manifest->size;
+ else end += index;
+
+ sint32 length = end - index - 1;
+ char* name = (char*)malloc(length + 1);
+ memcpy(name, &(ptr[index]), length);
+ name[length] = 0;
+ return name;
+ } else {
+ return 0;
+ }
+}
+
+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));
+
+ sprintf(temp, "%s:%s", vm->classpath, jarFile);
+ vm->setClasspath(temp);
+
+ ArrayUInt8* bytes = Reader::openFile(JnjvmClassLoader::bootstrapLoader,
+ jarFile);
+
+ ZipArchive archive(bytes);
+ if (archive.getOfscd() != -1) {
+ ZipFile* file = archive.getFile(PATH_MANIFEST);
+ if (file) {
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, &vm->allocator);
+ int ok = archive.readFile(res, file);
+ if (ok) {
+ char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS);
+ if (mainClass) {
+ className = mainClass;
+ } else {
+ printf("No Main-Class: in Manifest of archive %s.\n", jarFile);
+ }
+ } else {
+ printf("Can't extract Manifest file from archive %s\n", jarFile);
+ }
+ } else {
+ printf("Can't find Manifest file in archive %s\n", jarFile);
+ }
+ } else {
+ printf("Can't find archive %s\n", jarFile);
+ }
+}
+
+void ClArgumentsInfo::nyi() {
+ fprintf(stdout, "Not yet implemented\n");
+}
+
+void ClArgumentsInfo::printVersion() {
+ fprintf(stdout, "JnJVM for Java 1.1 -- 1.5\n");
+}
+
+void ClArgumentsInfo::printInformation() {
+ fprintf(stdout,
+ "Usage: java [-options] class [args...] (to execute a class)\n"
+ "or java [-options] -jar jarfile [args...]\n"
+ "(to execute a jar file) where options include:\n"
+ "-client to select the \"client\" VM\n"
+ "-server to select the \"server\" VM\n"
+ "-hotspot is a synonym for the \"client\" VM [deprecated]\n"
+ " The default VM is client.\n"
+ "\n"
+ "-cp <class search path of directories and zip/jar files>\n"
+ "-classpath <class search path of directories and zip/jar files>\n"
+ " A : separated list of directories, JAR archives,\n"
+ " and ZIP archives to search for class files.\n"
+ "-D<name>=<value>\n"
+ " set a system property\n"
+ "-verbose[:class|gc|jni]\n"
+ " enable verbose output\n"
+ "-version print product version and exit\n"
+ "-version:<value>\n"
+ " require the specified version to run\n"
+ "-showversion print product version and continue\n"
+ "-jre-restrict-search | -jre-no-restrict-search\n"
+ " include/exclude user private JREs in the version search\n"
+ "-? -help print this help message\n"
+ "-X print help on non-standard options\n"
+ "-ea[:<packagename>...|:<classname>]\n"
+ "-enableassertions[:<packagename>...|:<classname>]\n"
+ " enable assertions\n"
+ "-da[:<packagename>...|:<classname>]\n"
+ "-disableassertions[:<packagename>...|:<classname>]\n"
+ " disable assertions\n"
+ "-esa | -enablesystemassertions\n"
+ " enable system assertions\n"
+ "-dsa | -disablesystemassertions\n"
+ " disable system assertions\n"
+ "-agentlib:<libname>[=<options>]\n"
+ " load native agent library <libname>, e.g. -agentlib:hprof\n"
+ " see also, -agentlib:jdwp=help and -agentlib:hprof=help\n"
+ "-agentpath:<pathname>[=<options>]\n"
+ " load native agent library by full pathname\n"
+ "-javaagent:<jarpath>[=<options>]\n"
+ " load Java programming language agent, see java.lang.instrument\n");
+}
+
+void ClArgumentsInfo::readArgs(int argc, char** argv, Jnjvm* vm) {
+ className = 0;
+ appArgumentsPos = 0;
+ sint32 i = 1;
+ if (i == argc) printInformation();
+ while (i < argc) {
+ char* cur = argv[i];
+ if (!(strcmp(cur, "-client"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-server"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-classpath"))) {
+ ++i;
+ if (i == argc) printInformation();
+ else vm->setClasspath(argv[i]);
+ } else if (!(strcmp(cur, "-cp"))) {
+ ++i;
+ if (i == argc) printInformation();
+ else vm->setClasspath(argv[i]);
+ } else if (!(strcmp(cur, "-debug"))) {
+ nyi();
+ } else if (!(strncmp(cur, "-D", 2))) {
+ uint32 len = strlen(cur);
+ if (len == 2) {
+ printInformation();
+ } else {
+ char* key = &cur[2];
+ char* value = strchr(key, '=');
+ if (!value) {
+ printInformation();
+ return;
+ } else {
+ value[0] = 0;
+ vm->addProperty(key, &value[1]);
+ }
+ }
+ } else if (!(strncmp(cur, "-Xbootclasspath:", 16))) {
+ uint32 len = strlen(cur);
+ if (len == 16) {
+ printInformation();
+ } else {
+ char* path = &cur[16];
+ JnjvmClassLoader::bootstrapLoader->analyseClasspathEnv(path);
+ }
+ } else if (!(strcmp(cur, "-enableassertions"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-ea"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-disableassertions"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-da"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-enablesystemassertions"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-esa"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-disablesystemassertions"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-dsa"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-jar"))) {
+ ++i;
+ if (i == argc) {
+ printInformation();
+ } else {
+ extractClassFromJar(vm, argc, argv, i);
+ appArgumentsPos = i;
+ return;
+ }
+ } else if (!(strcmp(cur, "-jre-restrict-research"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-jre-no-restrict-research"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-noclassgc"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-ms"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-mx"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-ss"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-verbose"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-verbose:class"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-verbosegc"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-verbose:gc"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-verbose:jni"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-version"))) {
+ printVersion();
+ } else if (!(strcmp(cur, "-showversion"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-?"))) {
+ printInformation();
+ } else if (!(strcmp(cur, "-help"))) {
+ printInformation();
+ } else if (!(strcmp(cur, "-X"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-agentlib"))) {
+ nyi();
+ } else if (!(strcmp(cur, "-agentpath"))) {
+ nyi();
+ } else if (cur[0] == '-') {
+ } else if (!(strcmp(cur, "-javaagent"))) {
+ javaAgent(cur);
+ } else {
+ className = cur;
+ appArgumentsPos = i;
+ return;
+ }
+ ++i;
+ }
+}
+
+
+void Jnjvm::print(mvm::PrintBuffer* buf) const {
+ buf->write("Java isolate: ");
+ buf->write(name);
+
+}
+
+JnjvmClassLoader* Jnjvm::loadAppClassLoader() {
+ if (appClassLoader == 0) {
+ JavaObject* loader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this);
+ appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader);
+ }
+ return appClassLoader;
+}
+
+void Jnjvm::mapInitialThread() {
+ ClasspathThread::mapInitialThread(this);
+}
+
+void Jnjvm::loadBootstrap() {
+ JnjvmClassLoader* loader = JnjvmClassLoader::bootstrapLoader;
+#define LOAD_CLASS(cl) \
+ loader->loadName(cl->name, true, true, true);
+ LOAD_CLASS(Classpath::newClass);
+ LOAD_CLASS(Classpath::newConstructor);
+ LOAD_CLASS(Classpath::newMethod);
+ LOAD_CLASS(Classpath::newField);
+ LOAD_CLASS(Classpath::newStackTraceElement);
+ LOAD_CLASS(ClasspathException::InvocationTargetException);
+ LOAD_CLASS(ClasspathException::ArrayStoreException);
+ LOAD_CLASS(ClasspathException::ClassCastException);
+ LOAD_CLASS(ClasspathException::IllegalMonitorStateException);
+ LOAD_CLASS(ClasspathException::IllegalArgumentException);
+ LOAD_CLASS(ClasspathException::InterruptedException);
+ LOAD_CLASS(ClasspathException::IndexOutOfBoundsException);
+ LOAD_CLASS(ClasspathException::ArrayIndexOutOfBoundsException);
+ LOAD_CLASS(ClasspathException::NegativeArraySizeException);
+ LOAD_CLASS(ClasspathException::NullPointerException);
+ LOAD_CLASS(ClasspathException::SecurityException);
+ LOAD_CLASS(ClasspathException::ClassFormatError);
+ LOAD_CLASS(ClasspathException::ClassCircularityError);
+ LOAD_CLASS(ClasspathException::NoClassDefFoundError);
+ LOAD_CLASS(ClasspathException::UnsupportedClassVersionError);
+ LOAD_CLASS(ClasspathException::NoSuchFieldError);
+ LOAD_CLASS(ClasspathException::NoSuchMethodError);
+ LOAD_CLASS(ClasspathException::InstantiationError);
+ LOAD_CLASS(ClasspathException::IllegalAccessError);
+ LOAD_CLASS(ClasspathException::IllegalAccessException);
+ LOAD_CLASS(ClasspathException::VerifyError);
+ LOAD_CLASS(ClasspathException::ExceptionInInitializerError);
+ LOAD_CLASS(ClasspathException::LinkageError);
+ LOAD_CLASS(ClasspathException::AbstractMethodError);
+ LOAD_CLASS(ClasspathException::UnsatisfiedLinkError);
+ LOAD_CLASS(ClasspathException::InternalError);
+ LOAD_CLASS(ClasspathException::OutOfMemoryError);
+ LOAD_CLASS(ClasspathException::StackOverflowError);
+ LOAD_CLASS(ClasspathException::UnknownError);
+ LOAD_CLASS(ClasspathException::ClassNotFoundException);
+#undef LOAD_CLASS
+
+ mapInitialThread();
+ loadAppClassLoader();
+ JavaObject* obj = JavaThread::currentThread();
+ Classpath::setContextClassLoader->invokeIntSpecial(this, obj,
+ appClassLoader->getJavaClassLoader());
+ // load and initialise math since it is responsible for dlopen'ing
+ // libjavalang.so and we are optimizing some math operations
+ loader->loadName(loader->asciizConstructUTF8("java/lang/Math"),
+ true, true, true);
+}
+
+void Jnjvm::executeClass(const char* className, ArrayObject* args) {
+ try {
+ JavaJIT::invokeOnceVoid(this, appClassLoader, className, "main",
+ "([Ljava/lang/String;)V", ACC_STATIC, args);
+ }catch(...) {
+ }
+
+ JavaObject* exc = JavaThread::get()->pendingException;
+ if (exc) {
+ JavaThread::clearException();
+ JavaObject* obj = JavaThread::currentThread();
+ JavaObject* group =
+ ClasspathThread::group->getVirtualObjectField(obj);
+ try{
+ ClasspathThread::uncaughtException->invokeIntSpecial(this, group, obj,
+ exc);
+ }catch(...) {
+ printf("Even uncaught exception throwed an exception!\n");
+ assert(0);
+ }
+ }
+}
+
+void Jnjvm::executePremain(const char* className, JavaString* args,
+ JavaObject* instrumenter) {
+ JavaJIT::invokeOnceVoid(this, appClassLoader, className, "premain",
+ "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V",
+ ACC_STATIC, args, instrumenter);
+}
+
+void Jnjvm::waitForExit() {
+ threadSystem->nonDaemonLock->lock();
+ --(threadSystem->nonDaemonThreads);
+
+ while (threadSystem->nonDaemonThreads) {
+ threadSystem->nonDaemonVar->wait(threadSystem->nonDaemonLock);
+ }
+
+ threadSystem->nonDaemonLock->unlock();
+ return;
+}
+
+void Jnjvm::runMain(int argc, char** argv) {
+ ClArgumentsInfo info;
+
+ info.readArgs(argc, argv, this);
+ if (info.className) {
+ int pos = info.appArgumentsPos;
+ //llvm::cl::ParseCommandLineOptions(pos, argv,
+ // " JnJVM Java Virtual Machine\n");
+ argv = argv + pos - 1;
+ argc = argc - pos + 1;
+
+ loadBootstrap();
+#ifdef SERVICE_VM
+ ServiceDomain::initialise((ServiceDomain*)this);
+#endif
+
+ if (info.agents.size()) {
+ assert(0 && "implement me");
+ JavaObject* instrumenter = 0;//createInstrumenter();
+ for (std::vector< std::pair<char*, char*> >::iterator i =
+ info.agents.begin(),
+ e = info.agents.end(); i!= e; ++i) {
+ JavaString* args = asciizToStr(i->second);
+ executePremain(i->first, args, instrumenter);
+ }
+ }
+
+ ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString,
+ &allocator);
+ for (int i = 2; i < argc; ++i) {
+ args->elements[i - 2] = (JavaObject*)asciizToStr(argv[i]);
+ }
+
+ executeClass(info.className, args);
+ waitForExit();
+ }
+}
+
+void Jnjvm::runIsolate(const char* className, ArrayObject* args) {
+ Jnjvm *isolate = allocateIsolate();
+ isolate->loadBootstrap();
+ isolate->executeClass(className, args);
+ isolate->waitForExit();
+}
+
+Jnjvm* Jnjvm::allocateIsolate() {
+ Jnjvm *isolate= gc_new(Jnjvm)();
+
+#ifdef MULTIPLE_GC
+ isolate->GC = Collector::allocate();
+#endif
+ isolate->classpath = getenv("CLASSPATH");
+ if (!(isolate->classpath)) {
+ isolate->classpath = ".";
+ }
+
+ isolate->bootstrapThread = gc_new(JavaThread)();
+ isolate->bootstrapThread->initialise(0, isolate);
+ void* baseSP = mvm::Thread::get()->baseSP;
+ isolate->bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
+
+#ifdef MULTIPLE_GC
+ isolate->bootstrapThread->GC = isolate->GC;
+ isolate->GC->inject_my_thread(baseSP);
+#endif
+ isolate->bootstrapThread->baseSP = baseSP;
+ JavaThread::threadKey->set(isolate->bootstrapThread);
+
+ isolate->threadSystem = new ThreadSystem();
+ isolate->name = "isolate";
+ isolate->appClassLoader = 0;
+ isolate->jniEnv = &JNI_JNIEnvTable;
+ isolate->javavmEnv = &JNI_JavaVMTable;
+
+ isolate->hashStr = new StringMap();
+ isolate->globalRefsLock = mvm::Lock::allocNormal();
+#ifdef MULTIPLE_VM
+ isolate->statics = vm_new(isolate, StaticInstanceMap)();
+ isolate->delegatees = vm_new(isolate, DelegateeMap)();
+#endif
+
+ return isolate;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Aug 18 02:41:59 2008
@@ -24,6 +24,7 @@
namespace jnjvm {
+class ArrayObject;
class ArrayUInt8;
class Attribut;
class Class;
@@ -33,6 +34,7 @@
class JavaMethod;
class JavaObject;
class JavaString;
+class JavaThread;
class JnjvmClassLoader;
class JnjvmModule;
class JnjvmModuleProvider;
@@ -55,95 +57,133 @@
class AllocationMap;
class ZipArchive;
+/// ThreadSystem - Thread management of a JVM. Each JVM has one thread
+/// management system to count the number of non-daemon threads it owns.
+/// The initial thread of the JVM is a non-daemon thread. When there are
+/// no more non-daemon threads, the JVM stops executing.
+///
+class ThreadSystem {
+public:
+ /// nonDaemonThreads - Number of threads in the system that are not daemon
+ /// threads.
+ //
+ uint16 nonDaemonThreads;
+
+ /// nonDaemonLock - Protection lock for the nonDaemonThreads variable.
+ ///
+ mvm::Lock* nonDaemonLock;
+
+ /// nonDaemonVar - Condition variable to wake up the initial thread when it
+ /// waits for other non-daemon threads to end. The non-daemon thread that
+ /// decrements the nonDaemonThreads variable to zero wakes up the initial
+ /// thread.
+ ///
+ mvm::Cond* nonDaemonVar;
+
+ /// ThreadSystem - Allocates a thread system management, initializing the
+ /// lock, the condition variable and setting the initial number of non
+ /// daemon threads to one, for the initial thread.
+ ///
+ ThreadSystem() {
+ nonDaemonThreads = 1;
+ nonDaemonLock = mvm::Lock::allocNormal();
+ nonDaemonVar = mvm::Cond::allocCond();
+ }
+
+ /// ~ThreadSystem - Destroys the thread system manager. Destroys the lock and
+ /// the condition variable.
+ ///
+ ~ThreadSystem() {
+ delete nonDaemonLock;
+ delete nonDaemonVar;
+ }
+
+};
+
+/// Jnjvm - A JVM. Each execution of a program allocates a Jnjvm.
+///
class Jnjvm : public mvm::VirtualMachine {
+private:
+
+ /// bootstrapThread - The initial thread of this JVM.
+ ///
+ JavaThread* bootstrapThread;
+
+ /// error - Throws an exception in the execution of a JVM for the thread
+ /// that calls this functions. This is used internally by Jnjvm to control
+ /// which pair class/method are used.
+ ///
+ void error(Class* cl, JavaMethod* meth, const char* fmt, ...);
+
+ /// errorWithExcp - Throws an exception whose cause is the Java object excp.
+ ///
+ void errorWithExcp(Class* cl, JavaMethod* meth, const JavaObject* excp);
+
+ /// loadAppClassLoader - Loads the application class loader, so that VMKit
+ /// knowns which loader has to load the main class.
+ ///
+ JnjvmClassLoader* loadAppClassLoader();
+
+ /// mapInitialThread - Maps the initial native thread to a java/lang/Thread
+ /// object.
+ ///
+ void mapInitialThread();
+
+ /// loadBootstrap - Bootstraps the JVM, getting the class loader, initializing
+ /// bootstrap classes (e.g. java/lang/Class, java/lang/*Exception) and
+ /// mapping the initial thread.
+ ///
+ void loadBootstrap();
+
+ /// executeClass - Executes in the given JVM this main class with the given
+ /// Java args.
+ ///
+ void executeClass(const char* className, ArrayObject* args);
+
+ /// executePremain - Executes the premain class for the java/lang/instrument
+ /// feature.
+ ///
+ void executePremain(const char* className, JavaString* args,
+ JavaObject* instrumenter);
+
+ /// waitForExit - Waits that there are no more non-daemon threads in this JVM.
+ ///
+ void waitForExit();
+
+ /// runMain - Runs the application with the given command line.
+ ///
+ void runMain(int argc, char** argv);
+
+
public:
-#ifdef MULTIPLE_GC
- Collector* GC;
-#endif
- JavaAllocator allocator;
+
+ /// VT - The virtual table of this class.
+ ///
static VirtualTable* VT;
-
- static const char* dirSeparator;
- static const char* envSeparator;
- static const unsigned int Magic;
- // Misc constants
- static const double MaxDouble;
- static const double MinDouble;
- static const double MaxLongDouble;
- static const double MinLongDouble;
- static const double MaxIntDouble;
- static const double MinIntDouble;
- static const uint64 MaxLong;
- static const uint64 MinLong;
- static const uint32 MaxInt;
- static const uint32 MinInt;
- static const float MaxFloat;
- static const float MinFloat;
- static const float MaxIntFloat;
- static const float MinIntFloat;
- static const float MaxLongFloat;
- static const float MinLongFloat;
- static const float NaNFloat;
- static const double NaNDouble;
-
- // Exceptions name
- static const char* ArithmeticException;
- static const char* ClassNotFoundException;
- static const char* InvocationTargetException;
- static const char* ArrayStoreException;
- static const char* ClassCastException;
- static const char* IllegalMonitorStateException;
- static const char* IllegalArgumentException;
- static const char* InterruptedException;
- static const char* IndexOutOfBoundsException;
- static const char* ArrayIndexOutOfBoundsException;
- static const char* NegativeArraySizeException;
- static const char* NullPointerException;
- static const char* SecurityException;
- static const char* ClassFormatError;
- static const char* ClassCircularityError;
- static const char* NoClassDefFoundError;
- static const char* UnsupportedClassVersionError;
- static const char* NoSuchFieldError;
- static const char* NoSuchMethodError;
- static const char* InstantiationError;
- static const char* IllegalAccessError;
- static const char* IllegalAccessException;
- static const char* VerifyError;
- static const char* ExceptionInInitializerError;
- static const char* LinkageError;
- static const char* AbstractMethodError;
- static const char* UnsatisfiedLinkError;
- static const char* InternalError;
- static const char* OutOfMemoryError;
- static const char* StackOverflowError;
- static const char* UnknownError;
+ /// print - Prints the JVM for debugging purposes.
+ ///
+ virtual void print(mvm::PrintBuffer* buf) const;
+ /// tracer - Traces instances of this class.
+ ///
+ virtual void TRACER;
- // Exceptions
- void arrayStoreException();
- void indexOutOfBounds(const JavaObject* obj, sint32 entry);
- void negativeArraySizeException(int size);
- void nullPointerException(const char* fmt, ...);
- void illegalAccessException(const char* msg);
- void illegalMonitorStateException(const JavaObject* obj);
- void interruptedException(const JavaObject* obj);
- void initializerError(const JavaObject* excp);
- void invocationTargetException(const JavaObject* obj);
- void outOfMemoryError(sint32 n);
- void illegalArgumentExceptionForMethod(JavaMethod* meth, CommonClass* required,
- CommonClass* given);
- void illegalArgumentExceptionForField(JavaField* field, CommonClass* required,
- CommonClass* given);
- void illegalArgumentException(const char* msg);
- void classCastException(const char* msg);
- void unknownError(const char* fmt, ...);
- void error(const char* className, const char* fmt, ...);
- void verror(const char* className, const char* fmt, va_list ap);
- void errorWithExcp(const char* className, const JavaObject* excp);
+ /// dirSeparator - Directory separator for file paths, e.g. '\' for windows,
+ /// '/' for Unix.
+ ///
+ static const char* dirSeparator;
+
+ /// envSeparator - Paths separator for environment variables, e.g. ':'.
+ ///
+ static const char* envSeparator;
+ /// Magic - The magic number at the beginning of each .class file. 0xcafebabe.
+ ///
+ static const unsigned int Magic;
+ /// Lists of UTF8s used internaly in VMKit.
+ static const UTF8* NoClassDefFoundError;
static const UTF8* initName;
static const UTF8* clinitName;
static const UTF8* clinitType;
@@ -176,49 +216,151 @@
static const UTF8* tanh;
static const UTF8* finalize;
-
- void initialiseClass(CommonClass* cl);
-
- JavaString* asciizToStr(const char* asciiz);
- JavaString* UTF8ToStr(const UTF8* utf8);
-
+#ifdef MULTIPLE_GC
+ /// GC - The garbage collector of this JVM.
+ ///
+ Collector* GC;
+#endif
- JavaObject* getClassDelegatee(CommonClass*);
+ /// threadSystem - The thread system to manage non-daemon threads and
+ /// control the end of the JVM's execution.
+ ///
+ ThreadSystem* threadSystem;
- virtual void TRACER;
- virtual void print(mvm::PrintBuffer* buf) const {
- buf->write("Jnjvm<>");
- }
+ /// allocator - Memory allocator of this JVM.
+ ///
+ JavaAllocator allocator;
- ~Jnjvm();
- Jnjvm();
-
- void addProperty(char* key, char* value);
-
+ /// jniEnv - The JNI environment of this JVM.
+ ///
void* jniEnv;
+
+ /// javavmEnv - The Java VM environment of this JVM.
+ ///
const void* javavmEnv;
+
+ /// postProperties - Properties set at runtime and in command line.
+ ///
std::vector< std::pair<char*, char*> > postProperties;
+
+ /// nativeLibs - Native libraries (e.g. '.so') loaded by this JVM.
+ ///
std::vector<void*> nativeLibs;
- const char* classpath;
+ /// classpath - The CLASSPATH value, or the paths given in command line.
+ ///
+ const char* classpath;
+ /// globalRefs - Global references that JNI wants to protect.
+ ///
std::vector<JavaObject*, gc_allocator<JavaObject*> > globalRefs;
- mvm::Lock* globalRefsLock;
-
- void setClasspath(char* cp) {
- classpath = cp;
- }
+ /// globalRefsLock - Lock for adding a new global reference.
+ ///
+ mvm::Lock* globalRefsLock;
+
+ /// name - The name of this JVM.
+ ///
const char* name;
+
+ /// appClassLoader - The bootstrap class loader.
+ ///
JnjvmClassLoader* appClassLoader;
+
+ /// hashStr - Hash map of java/lang/String objects allocated by this JVM.
+ ///
StringMap * hashStr;
+
#ifdef MULTIPLE_VM
+ /// statics - The static instances of classes, in a multi-vm environment.
+ ///
StaticInstanceMap* statics;
+
+ /// delegatees - The java/lang/Class equivalents of internal classes. This is
+ /// also in a multi-vm environment.
+ ///
DelegateeMap* delegatees;
#endif
+
+
+ /// Exceptions - These are the only exceptions VMKit will make.
+ ///
+ void arrayStoreException();
+ void indexOutOfBounds(const JavaObject* obj, sint32 entry);
+ void negativeArraySizeException(int size);
+ void nullPointerException(const char* fmt, ...);
+ void illegalAccessException(const char* msg);
+ void illegalMonitorStateException(const JavaObject* obj);
+ void interruptedException(const JavaObject* obj);
+ void initializerError(const JavaObject* excp);
+ void invocationTargetException(const JavaObject* obj);
+ void outOfMemoryError(sint32 n);
+ void illegalArgumentExceptionForMethod(JavaMethod* meth, CommonClass* required,
+ CommonClass* given);
+ void illegalArgumentExceptionForField(JavaField* field, CommonClass* required,
+ CommonClass* given);
+ void illegalArgumentException(const char* msg);
+ void classCastException(const char* msg);
+ void unknownError(const char* fmt, ...);
+ void noSuchFieldError(CommonClass* cl, const UTF8* name);
+ void noSuchMethodError(CommonClass* cl, const UTF8* name);
+ void classFormatError(const char* fmt, ...);
+ void noClassDefFoundError(JavaObject* obj);
+ void noClassDefFoundError(const char* fmt, ...);
+ void classNotFoundException(JavaString* str);
+
+
+ /// initialiseClass - Initialise the class for this JVM, and call the
+ /// "<clinit>" function.
+ ///
+ void initialiseClass(CommonClass* cl);
+
+ /// asciizToStr - Constructs a java/lang/String object from the given asciiz.
+ ///
+ JavaString* asciizToStr(const char* asciiz);
+
+ /// UTF8ToStr - Constructs a java/lang/String object from the given UTF8.
+ ///
+ JavaString* UTF8ToStr(const UTF8* utf8);
+
+ /// getClassDelegatee - Get the java/lang/Class object representing the
+ /// internal class.
+ ///
+ JavaObject* getClassDelegatee(CommonClass*);
+
+ /// ~Jnjvm - Destroy the JVM.
+ ///
+ ~Jnjvm();
+
+ /// Jnjvm - Allocate a default JVM, for VT initialization.
+ ///
+ Jnjvm();
+ /// addProperty - Adds a new property in the postProperties map.
+ ///
+ void addProperty(char* key, char* value);
+
+ /// setClasspath - Sets the application classpath for the JVM.
+ ///
+ void setClasspath(char* cp) {
+ classpath = cp;
+ }
+
+ /// allocateIsolate - Allocates a new JVM.
+ ///
+ static Jnjvm* allocateIsolate();
+
+ /// runIsolate - Runs an isolate with the given main class and with
+ /// these Java args. This should be called internaly by the javax.isolate
+ /// package.
+ ///
+ static void runIsolate(const char* className, ArrayObject* args);
+ /// runApplication - Runs the application with the given command line.
+ /// User-visible function, inherited by the VirtualMachine class.
+ ///
virtual void runApplication(int argc, char** argv);
+
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Aug 18 02:41:59 2008
@@ -29,7 +29,7 @@
extern const char* GNUClasspathGlibj;
extern const char* GNUClasspathLibs;
-JnjvmBootstrapLoader* JnjvmClassLoader::createBootstrapLoader() {
+JnjvmBootstrapLoader* JnjvmBootstrapLoader::createBootstrapLoader() {
JnjvmBootstrapLoader* JCL = gc_new(JnjvmBootstrapLoader)();
JCL->TheModule = new JnjvmModule("Bootstrap JnJVM");
@@ -163,7 +163,7 @@
Reader reader(cl->bytes);
uint32 magic = reader.readU4();
if (magic != Jnjvm::Magic) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError, "bad magic number %p", magic);
+ JavaThread::get()->isolate->classFormatError("bad magic number %p", magic);
}
cl->minor = reader.readU2();
cl->major = reader.readU2();
@@ -175,7 +175,7 @@
ctpInfo->resolveClassName(reader.readU2());
if (!(thisClassName->equals(cl->name))) {
- JavaThread::get()->isolate->error(Jnjvm::ClassFormatError, "try to load %s and found class named %s",
+ JavaThread::get()->isolate->classFormatError("try to load %s and found class named %s",
cl->printString(), thisClassName->printString());
}
@@ -298,11 +298,10 @@
CommonClass* cl = internalLoad(name);
if (!cl && doThrow) {
- if (!memcmp(name->UTF8ToAsciiz(), Jnjvm::NoClassDefFoundError,
- strlen(Jnjvm::NoClassDefFoundError))) {
+ if (!(name->equals(Jnjvm::NoClassDefFoundError))) {
JavaThread::get()->isolate->unknownError("Unable to load NoClassDefFoundError");
}
- JavaThread::get()->isolate->error(Jnjvm::NoClassDefFoundError, "unable to load %s", name->printString());
+ JavaThread::get()->isolate->noClassDefFoundError("unable to load %s", name->printString());
}
if (cl && doResolve) cl->resolveClass(doClinit);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Aug 18 02:41:59 2008
@@ -15,6 +15,8 @@
#include "types.h"
+#include "mvm/Object.h"
+
namespace jnjvm {
class ArrayUInt8;
@@ -39,76 +41,193 @@
class UTF8Map;
class ZipArchive;
+/// JnjvmClassLoader - Runtime representation of a class loader. It contains
+/// its own tables (signatures, UTF8, types) which are mapped to a single
+/// table for non-isolate environments.
+///
class JnjvmClassLoader : public mvm::Object {
private:
+
+
+ /// isolate - Which isolate defined me? Null for the bootstrap class loader.
+ ///
+ Jnjvm* isolate;
+
+ /// javaLoder - The Java representation of the class loader. Null for the
+ /// bootstrap class loader.
+ ///
+ JavaObject* javaLoader;
+
+ /// internalLoad - Load the class with the given name.
+ ///
virtual CommonClass* internalLoad(const UTF8* utf8);
+
+ /// readParents - Reads the parents, i.e. super and interfaces, of the class.
+ ///
+ void readParents(Class* cl, Reader& reader);
+
+ /// loadParents - Loads and resolves the parents, i.e. super and interfarces,
+ /// of the class.
+ ///
+ void loadParents(Class* cl);
+
+ /// readAttributs - Reads the attributs of the class.
+ ///
+ void readAttributs(Class* cl, Reader& reader, std::vector<Attribut*> & attr);
+
+ /// readFields - Reads the fields of the class.
+ ///
+ void readFields(Class* cl, Reader& reader);
+
+ /// readMethods - Reads the methods of the class.
+ ///
+ void readMethods(Class* cl, Reader& reader);
+
+ /// readClass - Reads the class.
+ ///
+ void readClass(Class* cl);
+
+ /// JnjvmClassLoader - Allocate a user-defined class loader. Called on
+ /// first use of a Java class loader.
+ ///
+ JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* isolate);
+
+protected:
+
+ /// classes - The classes this class loader has loaded.
+ ///
+ ClassMap* classes;
+
+ /// javaTypes - Tables of Typedef defined by this class loader. Shared by all
+ /// class loaders in a no isolation configuration.
+ ///
+ TypeMap* javaTypes;
+
+ /// javaSignatures - Tables of Signdef defined by this class loader. Shared
+ /// by all class loaders in a no isolation configuration.
+ ///
+ SignMap* javaSignatures;
public:
-
+
+ /// VT - The virtual table of this class.
+ ///
static VirtualTable* VT;
+ /// allocator - Reference to the memory allocator, which will allocate UTF8s,
+ /// signatures and types.
+ ///
+ JavaAllocator* allocator;
+
+
+ /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared
+ /// by all class loaders in a no isolation configuration.
+ ///
+ UTF8Map * hashUTF8;
+
+ /// TheModule - JIT module for compiling methods.
+ ///
+ JnjvmModule* TheModule;
+
+ /// TheModuleProvider - JIT module provider for dynamic class loading and
+ /// lazy compilation.
+ ///
+ JnjvmModuleProvider* TheModuleProvider;
+
+ /// tracer - Traces a JnjvmClassLoader for GC.
+ ///
virtual void TRACER;
+
+ /// print - String representation of the loader for debugging purposes.
+ ///
virtual void print(mvm::PrintBuffer* buf) const {
buf->write("Java class loader<>");
}
- Jnjvm* isolate;
- JavaObject* javaLoader;
-
+ /// getJnjvmLoaderFromJavaObject - Return the Jnjvm runtime representation
+ /// of the given class loader.
+ ///
+ static JnjvmClassLoader* getJnjvmLoaderFromJavaObject(JavaObject*);
+
+ /// getJavaClassLoader - Return the Java representation of this class loader.
+ ///
JavaObject* getJavaClassLoader() {
return javaLoader;
}
- static JnjvmClassLoader* getJnjvmLoaderFromJavaObject(JavaObject*);
-
- ClassMap* classes;
-
- JavaAllocator* allocator;
- JnjvmModule* TheModule;
- JnjvmModuleProvider* TheModuleProvider;
-
- // Loads a Class
- virtual CommonClass* loadName(const UTF8* name, bool doResolve,
- bool doClinit, bool doThrow);
+ /// loadName - Loads the class of the given name.
+ ///
+ CommonClass* loadName(const UTF8* name, bool doResolve, bool doClinit,
+ bool doThrow);
- // Class lookup
+ /// lookupClassFromUTF8 - Lookup a class from an UTF8 name and load it.
+ ///
CommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
unsigned int len,
bool doResolve, bool doClinit, bool doThrow);
+
+ /// lookupClassFromJavaString - Lookup a class from a Java String and load it.
+ ///
CommonClass* lookupClassFromJavaString(JavaString* str,
bool doResolve, bool doClinit,
bool doThrow);
-
- void readParents(Class* cl, Reader& reader);
- void loadParents(Class* cl);
- void readAttributs(Class* cl, Reader& reader, std::vector<Attribut*> & attr);
- void readFields(Class* cl, Reader& reader);
- void readMethods(Class* cl, Reader& reader);
- void readClass(Class* cl);
- void initialiseClass(CommonClass* cl);
+
+ /// resolveClass - Resolves the class.
+ ///
void resolveClass(CommonClass* cl, bool doClinit);
+ /// lookupClass - Finds the class of th given name in the class loader's
+ /// table.
+ ///
CommonClass* lookupClass(const UTF8* utf8);
+ /// constructArray - Hashes a runtime representation of a class with
+ /// the given name.
+ ///
ClassArray* constructArray(const UTF8* name);
+
+ /// constructClass - Hashes a runtime representation of a class with
+ /// the given name.
+ ///
Class* constructClass(const UTF8* name);
+ /// constructType - Hashes a Typedef, an internal representation of a class
+ /// still not loaded.
+ ///
+ Typedef* constructType(const UTF8 * name);
+ /// constructSign - Hashes a Signdef, a method signature.
+ ///
+ Signdef* constructSign(const UTF8 * name);
+
+ /// asciizConstructUTF8 - Hashes an UTF8 created from the given asciiz.
+ ///
+ const UTF8* asciizConstructUTF8(const char* asciiz);
- TypeMap* javaTypes;
- SignMap* javaSignatures;
- UTF8Map * hashUTF8;
+ /// readerConstructUTF8 - Hashes an UTF8 created from the given Unicode
+ /// buffer.
+ ///
+ const UTF8* readerConstructUTF8(const uint16* buf, uint32 size);
+ /// bootstrapLoader - The bootstrap loader of the JVM. Loads the base
+ /// classes.
+ ///
static JnjvmBootstrapLoader* bootstrapLoader;
-
+
#ifdef MULTIPLE_VM
+ /// SharedLoader - Shared loader when multiple vms are executing.
+ ///
static JnjvmClassLoader* SharedLoader;
#endif
- Typedef* constructType(const UTF8 * name);
- Signdef* constructSign(const UTF8 * name);
-
+ /// ~JnjvmClassLoader - Destroy the loader. Depending on the JVM
+ /// configuration, this may destroy the tables, JIT module and
+ /// module provider.
+ ///
~JnjvmClassLoader();
+
+ /// JnjvmClassLoader - Default constructor, zeroes the field.
+ ///
JnjvmClassLoader() {
hashUTF8 = 0;
javaTypes = 0;
@@ -118,39 +237,66 @@
isolate = 0;
}
- JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* isolate);
- static JnjvmBootstrapLoader* createBootstrapLoader();
-
-
- const UTF8* asciizConstructUTF8(const char* asciiz);
-
- const UTF8* readerConstructUTF8(const uint16* buf, uint32 size);
-
-
};
+/// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which
+/// loads base classes, ie glibj.zip or rt.jar and -Xbootclasspath.
+///
class JnjvmBootstrapLoader : public JnjvmClassLoader {
private:
+ /// internalLoad - Load the class with the given name.
+ ///
virtual CommonClass* internalLoad(const UTF8* utf8);
+
+ /// bootClasspath - List of paths for the base classes.
+ ///
+ std::vector<const char*> bootClasspath;
+
+ /// bootArchives - List of .zip or .jar files that contain base classes.
+ ///
+ std::vector<ZipArchive*> bootArchives;
+
+ /// openName - Opens a file of the given name and returns it as an array
+ /// of byte.
+ ///
+ ArrayUInt8* openName(const UTF8* utf8);
public:
+ /// VT - The virtual table of this class.
+ ///
static VirtualTable* VT;
+ /// tracer - Traces instances of this class.
+ ///
virtual void TRACER;
+
+ /// print - String representation of the loader, for debugging purposes.
+ ///
virtual void print(mvm::PrintBuffer* buf) const {
buf->write("Jnjvm bootstrap loader<>");
}
- void analyseClasspathEnv(const char*);
-
+ /// libClasspathEnv - The paths for dynamic libraries of Classpath, separated
+ /// by ':'.
+ ///
const char* libClasspathEnv;
+
+ /// bootClasspathEnv - The path for base classes, seperated by '.'.
+ ///
const char* bootClasspathEnv;
- std::vector<const char*> bootClasspath;
- std::vector<ZipArchive*> bootArchives;
+
+ /// analyseClasspathEnv - Analyse the paths for base classes.
+ ///
+ void analyseClasspathEnv(const char*);
+
+ /// createBootstrapLoader - Creates the bootstrap loader, first thing
+ /// to do before any execution of a JVM.
+ ///
+ static JnjvmBootstrapLoader* createBootstrapLoader();
+
- ArrayUInt8* openName(const UTF8* utf8);
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=54909&r1=54908&r2=54909&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Mon Aug 18 02:41:59 2008
@@ -12,7 +12,6 @@
#include "JavaArray.h"
#include "JavaCache.h"
#include "JavaClass.h"
-#include "JavaIsolate.h"
#include "JavaObject.h"
#include "JavaThread.h"
#include "Jnjvm.h"
@@ -36,7 +35,6 @@
INIT(Jnjvm);
INIT(ClassMap);
INIT(StaticInstanceMap);
- INIT(JavaIsolate);
INIT(DelegateeMap);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
@@ -106,13 +104,8 @@
statics->MARK_AND_TRACE;
delegatees->MARK_AND_TRACE;
#endif
-
-}
-
-void JavaIsolate::TRACER {
- Jnjvm::PARENT_TRACER;
bootstrapThread->MARK_AND_TRACE;
- JnjvmClassLoader::bootstrapLoader->MARK_AND_TRACE;
+ JnjvmClassLoader::bootstrapLoader->MARK_AND_TRACE;
}
void ClassMap::TRACER {
More information about the vmkit-commits
mailing list