hotspot Cdiff src/share/vm/runtime/thread.hpp (original) (raw)

src/share/vm/runtime/thread.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File hotspot Cdiff 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"; }

*** 890,899 **** --- 893,939 ---- 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;

• // 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;

• // 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;

• // 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

• 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;

*** 904,913 **** --- 944,954 ---- 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;

*** 991,1000 **** --- 1032,1042 ----
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; }

*** 1249,1258 **** --- 1291,1312 ---- 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
• // 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; }

*** 1349,1358 **** --- 1403,1420 ---- 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 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); }

*** 1818,1829 **** 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; }

--- 1880,1894 ---- 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; }

src/share/vm/runtime/thread.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File