// Create an exception then throws it.
extern "C" void j3ThrowExceptionFromJIT() {
JavaObject *exc = 0;
llvm_gcroot(exc, 0);
JavaThread *th = JavaThread::get();
JavaMethod* meth = th->getCallingMethodLevel(0);
exc = th->getJVM()->CreateUnsatisfiedLinkError(meth);
j3ThrowException(exc);
}
extern "C" JavaObject* Java_gnu_classpath_VMStackWalker_getCallingClass__() {
JavaObject* res = 0;
llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
UserClass* cl = th->getCallingClassLevel(2);
if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());
END_NATIVE_EXCEPTION
return res;
}
extern "C" JavaObject* nativeGetCallingClass() {
JavaObject* res = 0;
llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
UserClass* cl = th->getCallingClassLevel(2);
if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());
END_NATIVE_EXCEPTION
return res;
}
extern "C" JavaObject* Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
JavaObject* res = 0;
llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
UserClass* cl = th->getCallingClassLevel(index);
if (cl) res = cl->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
return res;
}
inline ArraySInt8* getAttrBytes(JavaAttribute* annotationsAtt, Class* cl) {
ArraySInt8* ret = 0;
llvm_gcroot(ret, 0);
if (!annotationsAtt) return 0;
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
uint32 len = annotationsAtt->nbb;
ret = (ArraySInt8*)vm->upcalls->ArrayOfByte->doNew(len, vm);
Reader reader(annotationsAtt, cl->bytes);
for(uint32 i = 0; i < len; ++i) {
ArraySInt8::setElement(ret, reader.readS1(), i);
}
return ret;
}
extern "C" void* j3ResolveSpecialStub() {
JavaThread *th = JavaThread::get();
void* result = NULL;
// Lookup the caller of this class.
vmkit::StackWalker Walker(th);
++Walker; // Remove the stub.
vmkit::FrameInfo* FI = Walker.get();
assert(FI->Metadata != NULL && "Wrong stack trace");
JavaMethod* caller = (JavaMethod*)FI->Metadata;
// Lookup the method info in the constant pool of the caller.
uint16 ctpIndex = caller->lookupCtpIndex(FI);
assert(ctpIndex && "No constant pool index");
JavaConstantPool* ctpInfo = caller->classDef->getConstantPool();
CommonClass* cl = 0;
const UTF8* utf8 = 0;
Signdef* sign = 0;
ctpInfo->resolveMethod(ctpIndex, cl, utf8, sign);
UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
assert(lookup->isInitializing() && "Class not ready");
JavaMethod* callee =
lookup->lookupSpecialMethodDontThrow(utf8, sign->keyName, caller->classDef);
if (!callee) {
th->getJVM()->noSuchMethodError(lookup, utf8);
}
if (isAbstract(callee->access)) {
JavaThread::get()->getJVM()->abstractMethodError(callee->classDef, callee->name);
}
// Compile the found method.
result = callee->compiledPtr();
// Update the entry in the constant pool.
ctpInfo->ctpRes[ctpIndex] = result;
return result;
}
void JavaObject::waitIntern(
JavaObject* self, struct timeval* info, bool timed) {
llvm_gcroot(self, 0);
JavaLock* l = 0;
if (owner(self)) {
l = self->lock.changeToFatlock(self);
JavaThread* thread = JavaThread::get();
thread->waitsOn = l;
mvm::Cond& varcondThread = thread->varcond;
if (thread->interruptFlag != 0) {
thread->interruptFlag = 0;
thread->waitsOn = 0;
thread->getJVM()->interruptedException(self);
} else {
thread->state = JavaThread::StateWaiting;
if (l->firstThread) {
assert(l->firstThread->prevWaiting && l->firstThread->nextWaiting &&
"Inconsistent list");
if (l->firstThread->nextWaiting == l->firstThread) {
l->firstThread->nextWaiting = thread;
} else {
l->firstThread->prevWaiting->nextWaiting = thread;
}
thread->prevWaiting = l->firstThread->prevWaiting;
thread->nextWaiting = l->firstThread;
l->firstThread->prevWaiting = thread;
} else {
l->firstThread = thread;
thread->nextWaiting = thread;
thread->prevWaiting = thread;
}
assert(thread->prevWaiting && thread->nextWaiting && "Inconsistent list");
assert(l->firstThread->prevWaiting && l->firstThread->nextWaiting &&
"Inconsistent list");
bool timeout = false;
l->waitingThreads++;
while (!thread->interruptFlag && thread->nextWaiting) {
if (timed) {
timeout = varcondThread.timedWait(&l->internalLock, info);
if (timeout) break;
} else {
varcondThread.wait(&l->internalLock);
}
}
l->waitingThreads--;
assert((!l->firstThread || (l->firstThread->prevWaiting &&
l->firstThread->nextWaiting)) && "Inconsistent list");
bool interrupted = (thread->interruptFlag != 0);
if (interrupted || timeout) {
if (thread->nextWaiting) {
assert(thread->prevWaiting && "Inconsistent list");
if (l->firstThread != thread) {
thread->nextWaiting->prevWaiting = thread->prevWaiting;
thread->prevWaiting->nextWaiting = thread->nextWaiting;
assert(l->firstThread->prevWaiting &&
l->firstThread->nextWaiting && "Inconsistent list");
} else if (thread->nextWaiting == thread) {
l->firstThread = 0;
} else {
l->firstThread = thread->nextWaiting;
l->firstThread->prevWaiting = thread->prevWaiting;
thread->prevWaiting->nextWaiting = l->firstThread;
assert(l->firstThread->prevWaiting &&
l->firstThread->nextWaiting && "Inconsistent list");
}
thread->nextWaiting = 0;
thread->prevWaiting = 0;
} else {
assert(!thread->prevWaiting && "Inconstitent state");
// Notify lost, notify someone else.
notify(self);
}
} else {
assert(!thread->prevWaiting && !thread->nextWaiting &&
"Inconsistent state");
}
thread->state = JavaThread::StateRunning;
thread->waitsOn = 0;
if (interrupted) {
thread->interruptFlag = 0;
thread->getJVM()->interruptedException(self);
}
}
} else {
JavaThread::get()->getJVM()->illegalMonitorStateException(self);
}
assert(owner(self) && "Not owner after wait");
}