void VM_UnlinkSymbols::doit() {
JavaThread *thread = (JavaThread *)calling_thread();
assert(thread->is_Java_thread(), "must be a Java thread");
SymbolTable::unlink();
}
JavaCallWrapper::JavaCallWrapper(methodHandle callee_method, Handle receiver, JavaValue* result, TRAPS) {
JavaThread* thread = (JavaThread *)THREAD;
bool clear_pending_exception = true;
guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code");
assert(!thread->owns_locks(), "must release all locks when leaving VM");
guarantee(!thread->is_Compiler_thread(), "cannot make java calls from the compiler");
_result = result;
// Allocate handle block for Java code. This must be done before we change thread_state to _thread_in_Java_or_stub,
// since it can potentially block.
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
// After this, we are official in JavaCode. This needs to be done before we change any of the thread local
// info, since we cannot find oops before the new information is set up completely.
ThreadStateTransition::transition(thread, _thread_in_vm, _thread_in_Java);
// Make sure that we handle asynchronous stops and suspends _before_ we clear all thread state
// in JavaCallWrapper::JavaCallWrapper(). This way, we can decide if we need to do any pd actions
// to prepare for stop/suspend (flush register windows on sparcs, cache sp, or other state).
if (thread->has_special_runtime_exit_condition()) {
thread->handle_special_runtime_exit_condition();
if (HAS_PENDING_EXCEPTION) {
clear_pending_exception = false;
}
}
// Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing
// the JavaCallWrapper before the entry frame is on the stack.
_callee_method = callee_method();
_receiver = receiver();
#ifdef CHECK_UNHANDLED_OOPS
THREAD->allow_unhandled_oop(&_callee_method);
THREAD->allow_unhandled_oop(&_receiver);
#endif // CHECK_UNHANDLED_OOPS
_thread = (JavaThread *)thread;
_handles = _thread->active_handles(); // save previous handle block & Java frame linkage
// For the profiler, the last_Java_frame information in thread must always be in
// legal state. We have no last Java frame if last_Java_sp == NULL so
// the valid transition is to clear _last_Java_sp and then reset the rest of
// the (platform specific) state.
_anchor.copy(_thread->frame_anchor());
_thread->frame_anchor()->clear();
debug_only(_thread->inc_java_call_counter());
_thread->set_active_handles(new_handles); // install new handle block and reset Java frame linkage
assert (_thread->thread_state() != _thread_in_native, "cannot set native pc to NULL");
// clear any pending exception in thread (native calls start with no exception pending)
if(clear_pending_exception) {
_thread->clear_pending_exception();
}
if (_anchor.last_Java_sp() == NULL) {
_thread->record_base_of_stack_pointer();
}
}
void VM_ZombieAll::doit() {
JavaThread *thread = (JavaThread *)calling_thread();
assert(thread->is_Java_thread(), "must be a Java thread");
thread->make_zombies();
}