UserClass* JnjvmClassLoader::loadName(const UTF8* name, bool doResolve,
bool doThrow, JavaString* strName) {
llvm_gcroot(strName, 0);
UserClass* cl = internalLoad(name, doResolve, strName);
if (!cl && doThrow) {
Jnjvm* vm = JavaThread::get()->getJVM();
if (name->equals(bootstrapLoader->NoClassDefFoundError)) {
fprintf(stderr, "Unable to load NoClassDefFoundError");
abort();
}
if (TheCompiler->isStaticCompiling()) {
fprintf(stderr, "Could not find %s, needed for static compiling\n",
UTF8Buffer(name).cString());
abort();
}
vm->noClassDefFoundError(name);
}
ensureCached(cl);
return cl;
}
UserClass* JnjvmClassLoader::loadName(const UTF8* name, bool doResolve,
bool doThrow, JavaString* strName) {
llvm_gcroot(strName, 0);
UserClass* cl = internalLoad(name, doResolve, strName);
if (!cl && doThrow) {
Jnjvm* vm = JavaThread::get()->getJVM();
if (name->equals(bootstrapLoader->NoClassDefFoundError)) {
fprintf(stderr, "Unable to load NoClassDefFoundError");
abort();
}
if (TheCompiler->isStaticCompiling()) {
fprintf(stderr, "Could not find %s, needed for static compiling\n",
UTF8Buffer(name).cString());
abort();
}
vm->noClassDefFoundError(name);
}
if (cl && cl->classLoader != this) {
classes->lock.lock();
ClassMap::iterator End = classes->map.end();
ClassMap::iterator I = classes->map.find(cl->name);
if (I == End)
classes->map.insert(std::make_pair(cl->name, cl));
classes->lock.unlock();
}
return cl;
}
int main(int argc, char **argv, char **envp) {
llvm::llvm_shutdown_obj X;
// Initialize base components.
VmkitModule::initialise(argc, argv);
Collector::initialise(argc, argv);
// Create the allocator that will allocate the bootstrap loader and the JVM.
vmkit::BumpPtrAllocator Allocator;
JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, Comp, true);
Jnjvm* vm = new(Allocator, "VM") Jnjvm(Allocator, initialFrametables, loader);
// Run the application.
vm->runApplication(argc, argv);
vm->waitForExit();
System::Exit(0);
// Destroy everyone.
// vm->~Jnjvm();
// loader->~JnjvmBootstrapLoader();
return 0;
}
int main(int argc, char **argv, char **envp) {
llvm::llvm_shutdown_obj X;
// Initialize base components.
MvmModule::initialise();
Collector::initialise();
// Tell the compiler to run all optimizations.
StandardCompileOpts = true;
// Create the allocator that will allocate the bootstrap loader and the JVM.
mvm::BumpPtrAllocator Allocator;
JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, Comp, true);
Jnjvm* vm = new(Allocator, "VM") Jnjvm(Allocator, loader);
// Run the application.
vm->runApplication(argc, argv);
vm->waitForExit();
exit(0);
// Destroy everyone.
// vm->~Jnjvm();
// loader->~JnjvmBootstrapLoader();
return 0;
}
int JavaObjectThrowable::getStackTraceBase(JavaObjectThrowable * self) {
JavaObject * stack = NULL;
llvm_gcroot(self, 0);
llvm_gcroot(stack, 0);
if (!self->backtrace) return 0;
Jnjvm* vm = JavaThread::get()->getJVM();
stack = self->backtrace;
sint32 index = 2;;
while (index != JavaArray::getSize(stack)) {
vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
if (FI->Metadata == NULL) ++index;
else {
JavaMethod* meth = (JavaMethod*)FI->Metadata;
assert(meth && "Wrong stack trace");
if (meth->classDef->isSubclassOf(vm->upcalls->newThrowable)) {
++index;
} else return index;
}
}
assert(0 && "Invalid stack trace!");
return 0;
}
static void mainCompilerLoaderStart(JavaThread* th) {
Jnjvm* vm = th->getJVM();
JnjvmBootstrapLoader* bootstrapLoader = vm->bootstrapLoader;
JavaAOTCompiler* AOT = new JavaAOTCompiler("AOT");
AOT->compileClassLoader(bootstrapLoader);
AOT->printStats();
vm->exit();
}
JavaObjectMethod* JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
JavaObjectMethod* ret = 0;
JavaString* str = 0;
JavaObject* pArr = 0;
JavaObject* eArr = 0;
JavaObject* retTy = 0;
ArraySInt8* ann = 0;
ArraySInt8* pmAnn = 0;
ArraySInt8* defAnn = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(str, 0);
llvm_gcroot(pArr, 0);
llvm_gcroot(eArr, 0);
llvm_gcroot(retTy, 0);
llvm_gcroot(ann, 0);
llvm_gcroot(pmAnn, 0);
llvm_gcroot(defAnn, 0);
// TODO: check parameter types
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader * classLoader = meth->classDef->classLoader;
UserClass* Meth = vm->upcalls->newMethod;
ret = (JavaObjectMethod*)Meth->doNew(vm);
str = vm->internalUTF8ToStr(meth->name);
pArr = meth->getParameterTypes(classLoader);
eArr = meth->getExceptionTypes(classLoader);
retTy = meth->getReturnType(classLoader);
JavaString ** sig = getSignature(meth);
ann = getAnnotations(meth);
pmAnn = getParamAnnotations(meth);
defAnn = getAnnotationDefault(meth);
JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
Cl, /* declaring class */
&str, /* name */
&pArr, /* parameter types */
&retTy, /* return type */
&eArr, /* exceptions */
meth->access, /* modifiers */
i, /* slot */
sig, /* signature */
&ann, /* annotations */
&pmAnn, /* parameter annotations */
&defAnn); /* default annotations */
return ret;
}
JavaObjectField* JavaObjectField::createFromInternalField(JavaField* field, int i) {
JavaObjectField* ret = 0;
JavaString* name = 0;
ArraySInt8* ann = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(name, 0);
llvm_gcroot(ann, 0);
// TODO: check parameter types
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* Field = vm->upcalls->newField;
ret = (JavaObjectField*)Field->doNew(vm);
name = vm->internalUTF8ToStr(field->name);
//type->Class
JnjvmClassLoader* loader = field->classDef->classLoader;
UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
assert(fieldCl);
JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
JavaString** sig = getSignature(field);
ann = getAnnotations(field);
/* java.reflect.Field(
* Class declaringClass,
* String name,
* Class type,
* int modifiers,
* int slot,
* String signature,
* byte[] annotations)
*/
vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
Cl,
&name,
type,
field->access,
i,
sig,
&ann);
return ret;
}
extern "C" JavaString* Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {
JavaString* ret = 0;
llvm_gcroot(str, 0);
llvm_gcroot(ret, 0);
BEGIN_NATIVE_EXCEPTION(0)
vmkit::ThreadAllocator allocator;
char* buf = JavaString::strToAsciiz(str, &allocator);
char* res = getenv(buf);
if (res) {
Jnjvm* vm = JavaThread::get()->getJVM();
ret = vm->asciizToStr(res);
}
END_NATIVE_EXCEPTION
return ret;
}
extern "C" JavaString* nativeGetenv(JavaString* str) {
JavaString* ret = 0;
llvm_gcroot(str, 0);
llvm_gcroot(ret, 0);
BEGIN_NATIVE_EXCEPTION(0)
mvm::ThreadAllocator allocator;
char* buf = JavaString::strToAsciiz(str, &allocator);
char* res = getenv(buf);
if (res) {
Jnjvm* vm = JavaThread::get()->getJVM();
ret = vm->asciizToStr(res);
}
END_NATIVE_EXCEPTION
return ret;
}
extern "C" JavaString* nativeInternString(JavaString* obj) {
const ArrayUInt16* array = 0;
JavaString* res = 0;
llvm_gcroot(obj, 0);
llvm_gcroot(array, 0);
llvm_gcroot(res, 0);
// If the string is already interned, just return.
if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
array = JavaString::strToArray(obj, vm);
res = vm->constructString(array);
END_NATIVE_EXCEPTION
return res;
}
int JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
JavaObject * stack = NULL;
llvm_gcroot(self, 0);
llvm_gcroot(stack, 0);
if (!self->backtrace) return 0;
Jnjvm* vm = JavaThread::get()->getJVM();
stack = self->backtrace;
sint32 index = getStackTraceBase(self);
sint32 size = 0;
sint32 cur = index;
while (cur < JavaArray::getSize(stack)) {
vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
++cur;
if (FI->Metadata != NULL) ++size;
}
return size;
}
int main(int argc, char **argv, char **envp) {
llvm::llvm_shutdown_obj X;
bool EmitClassBytes = false;
static const char* EmitClassBytesStr = "-emit-class-bytes";
for (int i = 0; i < argc; i++) {
if (!strncmp(argv[i], EmitClassBytesStr, strlen(EmitClassBytesStr))) {
EmitClassBytes = true;
break;
}
}
std::string OutputFilename;
// Initialize base components.
VmkitModule::initialise(argc, argv);
Collector::initialise(argc, argv);
// Create the allocator that will allocate the bootstrap loader and the JVM.
vmkit::BumpPtrAllocator Allocator;
JavaAOTCompiler* AOT;
if (EmitClassBytes) {
AOT = new JavaAOTCompiler("AOT");
OutputFilename = "classes.bc";
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, AOT, true);
AOT->generateClassBytes(loader);
} else {
OutputFilename = "generated.bc";
JavaJITCompiler* JIT = JavaJITCompiler::CreateCompiler("JIT");
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, JIT, true);
Jnjvm* vm = new(Allocator, "VM") Jnjvm(Allocator, frametables, loader);
// Run the application.
vm->runApplication(argc, argv);
vm->waitForExit();
// Now AOT Compile all compiled methods.
vm->doExit = false;
JavaThread* th = new JavaThread(vm);
vm->setMainThread(th);
th->start((void (*)(vmkit::Thread*))mainCompilerLoaderStart);
vm->waitForExit();
AOT = (JavaAOTCompiler*)loader->getCompiler();
}
// Emit the bytecode in file.
std::string ErrorInfo;
std::auto_ptr<llvm::raw_ostream> Out
(new llvm::raw_fd_ostream(OutputFilename.c_str(), ErrorInfo,
llvm::raw_fd_ostream::F_Binary));
if (!ErrorInfo.empty()) {
llvm::errs() << ErrorInfo << '\n';
return 1;
}
// Make sure that the Out file gets unlinked from the disk if we get a
// SIGINT.
llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OutputFilename));
llvm::WriteBitcodeToFile(AOT->getLLVMModule(), *Out);
return 0;
}
