Cross Reference: /openjdk7/hotspot/src/cpu/x86/vm/assembler

Lines Matching defs:thread
5551   // See whether the lock is currently biased toward our thread and
5574   // Note that because there is no current thread register on x86 we
5620   // toward the current thread. Note that we must be absolutely sure
5632   // don't accidentally blow away another thread's valid bias.
5648   // If the biasing toward our thread failed, this means that
5649   // another thread succeeded in biasing it toward itself and we
5667   // the bias from one thread to another directly in this situation.
5685   // If the biasing toward our thread failed, then another thread
5703   // that another thread raced us for the privilege of revoking the
5723   // the result of the above CAS, some thread must have succeeded in
6008   JavaThread* thread = JavaThread::current();
6009   JavaThreadState saved_state = thread->thread_state();
6010   thread->set_thread_state(_thread_in_vm);
6012     JavaThread* thread = JavaThread::current();
6013     JavaThreadState saved_state = thread->thread_state();
6014     thread->set_thread_state(_thread_in_vm);
6031   ThreadStateTransition::transition(thread, _thread_in_vm, saved_state);
6152   // See whether the lock is currently biased toward our thread and
6199   // toward the current thread. Note that we must be absolutely sure
6211   // don't accidentally blow away another thread's valid bias.
6220   // If the biasing toward our thread failed, this means that
6221   // another thread succeeded in biasing it toward itself and we
6239   // the bias from one thread to another directly in this situation.
6249   // If the biasing toward our thread failed, then another thread
6267   // that another thread raced us for the privilege of revoking the
6279   // the result of the above CAS, some thread must have succeeded in
6610     JavaThread* thread = JavaThread::current();
6611     JavaThreadState saved_state = thread->thread_state();
6612     thread->set_thread_state(_thread_in_vm);
6627     ThreadStateTransition::transition(thread, _thread_in_vm, saved_state);
6785   // Note: we do not have to check the thread ID for two reasons.
6788   // lock, the object could not be rebiased toward another thread, so
6907   Register thread = LP64_ONLY(r15_thread) NOT_LP64(noreg);
6908   call_VM_base(oop_result, thread, last_java_sp, entry_point, number_of_arguments, check_exceptions);
6954   Register thread = LP64_ONLY(r15_thread) NOT_LP64(noreg);
6955   MacroAssembler::call_VM_base(oop_result, thread, last_java_sp, entry_point, number_of_arguments, check_exceptions);
7027   // push java thread (becomes first argument of C function)
7041   // restore the thread (cannot use the pushed argument since arguments
7089   // get oop result if there is one and reset the value in the thread
7585   // keep it on the thread's stack to compute 2^int(X) later
7591   fistp_s(Address(rsp,0));  // move int(X) as integer to thread's stack. Stack: X-int(X) ...
7755     // move int(Y) as 64 bit integer to thread's stack
7763     // integer indefinite value so overwrite int(Y) on the thread's
8303 // Write serialization page so VM thread can do a pseudo remote membar.
8304 // We use the current thread pointer to calculate a thread specific
8307 void MacroAssembler::serialize_memory(Register thread, Register tmp) {
8308   movl(tmp, thread);
8322 // in the (thread-local) JavaThread object. When leaving C land, the last Java fp
8590                                           Register thread,
8600   assert(thread == r15_thread, "must be");
8613   Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
8615   Address index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
8617   Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
8639   // Can we store original value in the thread's buffer?
8677   NOT_LP64( push(thread); )
8681     pass_arg1(this, thread);
8685     call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), pre_val, thread);
8688   NOT_LP64( pop(thread); )
8704                                            Register thread,
8708   assert(thread == r15_thread, "must be");
8711   Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
8713   Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
8786   push(thread);
8787   call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), card_addr, thread);
8788   pop(thread);
8892   Register thread = NOT_LP64(t1) LP64_ONLY(r15_thread);
8896   NOT_LP64(get_thread(thread));
8898   movptr(obj, Address(thread, JavaThread::tlab_top_offset()));
8904   cmpptr(end, Address(thread, JavaThread::tlab_end_offset()));
8908   movptr(Address(thread, JavaThread::tlab_top_offset()), end);
9024 void MacroAssembler::incr_allocated_bytes(Register thread,
9028   if (!thread->is_valid()) {
9030     thread = r15_thread;
9033     thread = t1;
9034     get_thread(thread);
9040     addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
9042     addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
9046     addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
9048     addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
9050   adcl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())+4), 0);