59 private: 60 JvmtiThreadState* state; 61 public: 62 JvmtiEnvThreadStateIterator(JvmtiThreadState* thread_state); 63 ~JvmtiEnvThreadStateIterator(); 64 JvmtiEnvThreadState* first(); 65 JvmtiEnvThreadState* next(JvmtiEnvThreadState* ets); 66 }; 67 68 69 /////////////////////////////////////////////////////////////// 70 // 71 // class JvmtiThreadState 72 // 73 // The Jvmti state for each thread (across all JvmtiEnv): 74 // 1. Local table of enabled events. 75 class JvmtiThreadState : public CHeapObj<mtInternal> { 76 private: 77 friend class JvmtiEnv; 78 JavaThread *_thread; 79 bool _exception_detected; 80 bool _exception_caught; 81 bool _hide_single_stepping; 82 bool _pending_step_for_popframe; 83 bool _pending_step_for_earlyret; 84 int _hide_level; 85 86 // Used to send class being redefined/retransformed and kind of transform 87 // info to the class file load hook event handler. 88 KlassHandle *_class_being_redefined; 89 JvmtiClassLoadKind _class_load_kind; 90 91 // This is only valid when is_interp_only_mode() returns true 92 int _cur_stack_depth; 93 94 JvmtiThreadEventEnable _thread_event_enable; 95 96 // for support of JvmtiEnvThreadState 97 JvmtiEnvThreadState* _head_env_thread_state; 98 99 // doubly-linked linear list of active thread state 100 // needed in order to iterate the list without holding Threads_lock 101 static JvmtiThreadState *_head; 102 JvmtiThreadState *_next; 103 JvmtiThreadState *_prev; 104 105 // holds the current dynamic code event collector, NULL if no event collector in use 144 static JvmtiThreadState *first() { 145 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); 146 return _head; 147 } 148 149 JvmtiThreadState *next() { 150 return _next; 151 } 152 153 // Current stack depth is only valid when is_interp_only_mode() returns true. 154 // These functions should only be called at a safepoint - usually called from same thread. 155 // Returns the number of Java activations on the stack. 156 int cur_stack_depth(); 157 void invalidate_cur_stack_depth(); 158 void incr_cur_stack_depth(); 159 void decr_cur_stack_depth(); 160 161 int count_frames(); 162 163 inline JavaThread *get_thread() { return _thread; } 164 inline bool is_exception_detected() { return _exception_detected; } 165 inline bool is_exception_caught() { return _exception_caught; } 166 inline void set_exception_detected() { _exception_detected = true; 167 _exception_caught = false; } 168 inline void clear_exception_detected() { 169 _exception_detected = false; 170 assert(_exception_caught == false, "_exception_caught is out of phase"); 171 } 172 inline void set_exception_caught() { _exception_caught = true; 173 _exception_detected = false; } 174 175 inline void clear_hide_single_stepping() { 176 if (_hide_level > 0) { 177 _hide_level--; 178 } else { 179 assert(_hide_single_stepping, "hide_single_stepping is out of phase"); 180 _hide_single_stepping = false; 181 } 182 } 183 inline bool hide_single_stepping() { return _hide_single_stepping; } 184 inline void set_hide_single_stepping() { 185 if (_hide_single_stepping) { 186 _hide_level++; 187 } else { 188 assert(_hide_level == 0, "hide_level is out of phase"); 189 _hide_single_stepping = true; 190 } 191 } 192 193 // Step pending flag is set when PopFrame is called and it is cleared | 59 private: 60 JvmtiThreadState* state; 61 public: 62 JvmtiEnvThreadStateIterator(JvmtiThreadState* thread_state); 63 ~JvmtiEnvThreadStateIterator(); 64 JvmtiEnvThreadState* first(); 65 JvmtiEnvThreadState* next(JvmtiEnvThreadState* ets); 66 }; 67 68 69 /////////////////////////////////////////////////////////////// 70 // 71 // class JvmtiThreadState 72 // 73 // The Jvmti state for each thread (across all JvmtiEnv): 74 // 1. Local table of enabled events. 75 class JvmtiThreadState : public CHeapObj<mtInternal> { 76 private: 77 friend class JvmtiEnv; 78 JavaThread *_thread; 79 bool _hide_single_stepping; 80 bool _pending_step_for_popframe; 81 bool _pending_step_for_earlyret; 82 int _hide_level; 83 84 public: 85 enum ExceptionState { 86 ES_CLEARED, 87 ES_DETECTED, 88 ES_CAUGHT 89 }; 90 91 private: 92 ExceptionState _exception_state; 93 94 // Used to send class being redefined/retransformed and kind of transform 95 // info to the class file load hook event handler. 96 KlassHandle *_class_being_redefined; 97 JvmtiClassLoadKind _class_load_kind; 98 99 // This is only valid when is_interp_only_mode() returns true 100 int _cur_stack_depth; 101 102 JvmtiThreadEventEnable _thread_event_enable; 103 104 // for support of JvmtiEnvThreadState 105 JvmtiEnvThreadState* _head_env_thread_state; 106 107 // doubly-linked linear list of active thread state 108 // needed in order to iterate the list without holding Threads_lock 109 static JvmtiThreadState *_head; 110 JvmtiThreadState *_next; 111 JvmtiThreadState *_prev; 112 113 // holds the current dynamic code event collector, NULL if no event collector in use 152 static JvmtiThreadState *first() { 153 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); 154 return _head; 155 } 156 157 JvmtiThreadState *next() { 158 return _next; 159 } 160 161 // Current stack depth is only valid when is_interp_only_mode() returns true. 162 // These functions should only be called at a safepoint - usually called from same thread. 163 // Returns the number of Java activations on the stack. 164 int cur_stack_depth(); 165 void invalidate_cur_stack_depth(); 166 void incr_cur_stack_depth(); 167 void decr_cur_stack_depth(); 168 169 int count_frames(); 170 171 inline JavaThread *get_thread() { return _thread; } 172 173 inline bool is_exception_detected() { return _exception_state == ES_DETECTED; } 174 inline bool is_exception_caught() { return _exception_state == ES_CAUGHT; } 175 176 inline void set_exception_detected() { _exception_state = ES_DETECTED; } 177 inline void set_exception_caught() { _exception_state = ES_CAUGHT; } 178 179 inline void clear_exception_state() { _exception_state = ES_CLEARED; } 180 181 // We need to save and restore exception state inside JvmtiEventMark 182 inline void save_exception_state(ExceptionState *state) { *state = _exception_state; } 183 inline void restore_exception_state(ExceptionState state) { _exception_state = state; } 184 185 inline void clear_hide_single_stepping() { 186 if (_hide_level > 0) { 187 _hide_level--; 188 } else { 189 assert(_hide_single_stepping, "hide_single_stepping is out of phase"); 190 _hide_single_stepping = false; 191 } 192 } 193 inline bool hide_single_stepping() { return _hide_single_stepping; } 194 inline void set_hide_single_stepping() { 195 if (_hide_single_stepping) { 196 _hide_level++; 197 } else { 198 assert(_hide_level == 0, "hide_level is out of phase"); 199 _hide_single_stepping = true; 200 } 201 } 202 203 // Step pending flag is set when PopFrame is called and it is cleared |