< prev index next >
src/share/vm/runtime/thread.hpp
Print this page
*** 327,336 ****
--- 327,339 ----
virtual bool is_Watcher_thread() const { return false; }
virtual bool is_ConcurrentGC_thread() const { return false; }
virtual bool is_Named_thread() const { return false; }
virtual bool is_Worker_thread() const { return false; }
+ // Can this thread make Java upcalls
+ virtual bool can_call_java() const { return false; }
+
// Casts
virtual WorkerThread* as_Worker_thread() const { return NULL; }
virtual char* name() const { return (char*)"Unknown thread"; }
*** 898,907 ****
--- 901,947 ----
stack_guard_enabled // enabled
};
private:
+ #if INCLUDE_JVMCI
+ // The _pending_* fields below are used to communicate extra information
+ // from an uncommon trap in JVMCI compiled code to the uncommon trap handler.
+
+ // Communicates the DeoptReason and DeoptAction of the uncommon trap
+ int _pending_deoptimization;
+
+ // Specifies whether the uncommon trap is to bci 0 of a synchronized method
+ // before the monitor has been acquired.
+ bool _pending_monitorenter;
+
+ // Specifies if the DeoptReason for the last uncommon trap was Reason_transfer_to_interpreter
+ bool _pending_transfer_to_interpreter;
+
+ // An object that JVMCI compiled code can use to further describe and
+ // uniquely identify the speculative optimization guarded by the uncommon trap
+ oop _pending_failed_speculation;
+
+ // These fields are mutually exclusive in terms of live ranges.
+ union {
+ // Communicates the pc at which the most recent implicit exception occurred
+ // from the signal handler to a deoptimization stub.
+ address _implicit_exception_pc;
+
+ // Communicates an alternative call target to an i2c stub from a JavaCall .
+ address _alternate_call_target;
+ } _jvmci;
+
+ // Support for high precision, thread sensitive counters in JVMCI compiled code.
+ jlong* _jvmci_counters;
+
+ public:
+ static jlong* _jvmci_old_thread_counters;
+ static void collect_counters(typeArrayOop array);
+ private:
+ #endif // INCLUDE_JVMCI
+
StackGuardState _stack_guard_state;
// Precompute the limit of the stack as used in stack overflow checks.
// We load it from here to simplify the stack overflow check in assembly.
address _stack_overflow_limit;
*** 912,921 ****
--- 952,962 ----
volatile oop _exception_oop; // Exception thrown in compiled code
volatile address _exception_pc; // PC where exception happened
volatile address _exception_handler_pc; // PC for handler of exception
volatile int _is_method_handle_return; // true (== 1) if the current exception PC is a MethodHandle call site.
+ private:
// support for JNI critical regions
jint _jni_active_critical; // count of entries into JNI critical region
// Checked JNI: function name requires exception check
char* _pending_jni_exception_check_fn;
*** 999,1008 ****
--- 1040,1050 ----
void cleanup_failed_attach_current_thread();
// Testers
virtual bool is_Java_thread() const { return true; }
+ virtual bool can_call_java() const { return true; }
// Thread chain operations
JavaThread* next() const { return _next; }
void set_next(JavaThread* p) { _next = p; }
*** 1257,1266 ****
--- 1299,1320 ----
void set_vm_result_2 (Metadata* x) { _vm_result_2 = x; }
MemRegion deferred_card_mark() const { return _deferred_card_mark; }
void set_deferred_card_mark(MemRegion mr) { _deferred_card_mark = mr; }
+ #if INCLUDE_JVMCI
+ int pending_deoptimization() const { return _pending_deoptimization; }
+ oop pending_failed_speculation() const { return _pending_failed_speculation; }
+ bool has_pending_monitorenter() const { return _pending_monitorenter; }
+ void set_pending_monitorenter(bool b) { _pending_monitorenter = b; }
+ void set_pending_deoptimization(int reason) { _pending_deoptimization = reason; }
+ void set_pending_failed_speculation(oop failed_speculation) { _pending_failed_speculation = failed_speculation; }
+ void set_pending_transfer_to_interpreter(bool b) { _pending_transfer_to_interpreter = b; }
+ void set_jvmci_alternate_call_target(address a) { assert(_jvmci._alternate_call_target == NULL, "must be"); _jvmci._alternate_call_target = a; }
+ void set_jvmci_implicit_exception_pc(address a) { assert(_jvmci._implicit_exception_pc == NULL, "must be"); _jvmci._implicit_exception_pc = a; }
+ #endif // INCLUDE_JVMCI
+
// Exception handling for compiled methods
oop exception_oop() const { return _exception_oop; }
address exception_pc() const { return _exception_pc; }
address exception_handler_pc() const { return _exception_handler_pc; }
bool is_method_handle_return() const { return _is_method_handle_return == 1; }
*** 1357,1366 ****
--- 1411,1428 ----
static ByteSize vm_result_offset() { return byte_offset_of(JavaThread, _vm_result); }
static ByteSize vm_result_2_offset() { return byte_offset_of(JavaThread, _vm_result_2); }
static ByteSize thread_state_offset() { return byte_offset_of(JavaThread, _thread_state); }
static ByteSize saved_exception_pc_offset() { return byte_offset_of(JavaThread, _saved_exception_pc); }
static ByteSize osthread_offset() { return byte_offset_of(JavaThread, _osthread); }
+ #if INCLUDE_JVMCI
+ static ByteSize pending_deoptimization_offset() { return byte_offset_of(JavaThread, _pending_deoptimization); }
+ static ByteSize pending_monitorenter_offset() { return byte_offset_of(JavaThread, _pending_monitorenter); }
+ static ByteSize pending_failed_speculation_offset() { return byte_offset_of(JavaThread, _pending_failed_speculation); }
+ static ByteSize jvmci_alternate_call_target_offset() { return byte_offset_of(JavaThread, _jvmci._alternate_call_target); }
+ static ByteSize jvmci_implicit_exception_pc_offset() { return byte_offset_of(JavaThread, _jvmci._implicit_exception_pc); }
+ static ByteSize jvmci_counters_offset() { return byte_offset_of(JavaThread, _jvmci_counters); }
+ #endif // INCLUDE_JVMCI
static ByteSize exception_oop_offset() { return byte_offset_of(JavaThread, _exception_oop); }
static ByteSize exception_pc_offset() { return byte_offset_of(JavaThread, _exception_pc); }
static ByteSize exception_handler_pc_offset() { return byte_offset_of(JavaThread, _exception_handler_pc); }
static ByteSize stack_overflow_limit_offset() { return byte_offset_of(JavaThread, _stack_overflow_limit); }
static ByteSize is_method_handle_return_offset() { return byte_offset_of(JavaThread, _is_method_handle_return); }
*** 1826,1837 ****
static CompilerThread* current();
CompilerThread(CompileQueue* queue, CompilerCounters* counters);
bool is_Compiler_thread() const { return true; }
! // Hide this compiler thread from external view.
! bool is_hidden_from_external_view() const { return true; }
void set_compiler(AbstractCompiler* c) { _compiler = c; }
AbstractCompiler* compiler() const { return _compiler; }
CompileQueue* queue() const { return _queue; }
--- 1888,1902 ----
static CompilerThread* current();
CompilerThread(CompileQueue* queue, CompilerCounters* counters);
bool is_Compiler_thread() const { return true; }
!
! virtual bool can_call_java() const;
!
! // Hide native compiler threads from external view.
! bool is_hidden_from_external_view() const { return !can_call_java(); }
void set_compiler(AbstractCompiler* c) { _compiler = c; }
AbstractCompiler* compiler() const { return _compiler; }
CompileQueue* queue() const { return _queue; }
< prev index next >