0
|
1 /*
|
|
2 * Copyright 2003-2006 Sun Microsystems, Inc. All Rights Reserved.
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 *
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
7 * published by the Free Software Foundation.
|
|
8 *
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
13 * accompanied this code).
|
|
14 *
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 *
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 * have any questions.
|
|
22 *
|
|
23 */
|
|
24
|
|
25 # include "incls/_precompiled.incl"
|
|
26 # include "incls/_jvmtiEnvThreadState.cpp.incl"
|
|
27
|
|
28
|
|
29 ///////////////////////////////////////////////////////////////
|
|
30 //
|
|
31 // class JvmtiFramePop
|
|
32 //
|
|
33
|
|
34 #ifndef PRODUCT
|
|
35 void JvmtiFramePop::print() {
|
|
36 tty->print_cr("_frame_number=%d", _frame_number);
|
|
37 }
|
|
38 #endif
|
|
39
|
|
40
|
|
41 ///////////////////////////////////////////////////////////////
|
|
42 //
|
|
43 // class JvmtiFramePops - private methods
|
|
44 //
|
|
45
|
|
46 void
|
|
47 JvmtiFramePops::set(JvmtiFramePop& fp) {
|
|
48 if (_pops->find(fp.frame_number()) < 0) {
|
|
49 _pops->append(fp.frame_number());
|
|
50 }
|
|
51 }
|
|
52
|
|
53
|
|
54 void
|
|
55 JvmtiFramePops::clear(JvmtiFramePop& fp) {
|
|
56 assert(_pops->length() > 0, "No more frame pops");
|
|
57
|
|
58 _pops->remove(fp.frame_number());
|
|
59 }
|
|
60
|
|
61
|
|
62 int
|
|
63 JvmtiFramePops::clear_to(JvmtiFramePop& fp) {
|
|
64 int cleared = 0;
|
|
65 int index = 0;
|
|
66 while (index < _pops->length()) {
|
|
67 JvmtiFramePop pop = JvmtiFramePop(_pops->at(index));
|
|
68 if (pop.above_on_stack(fp)) {
|
|
69 _pops->remove_at(index);
|
|
70 ++cleared;
|
|
71 } else {
|
|
72 ++index;
|
|
73 }
|
|
74 }
|
|
75 return cleared;
|
|
76 }
|
|
77
|
|
78
|
|
79 ///////////////////////////////////////////////////////////////
|
|
80 //
|
|
81 // class JvmtiFramePops - public methods
|
|
82 //
|
|
83
|
|
84 JvmtiFramePops::JvmtiFramePops() {
|
|
85 _pops = new (ResourceObj::C_HEAP) GrowableArray<int> (2, true);
|
|
86 }
|
|
87
|
|
88 JvmtiFramePops::~JvmtiFramePops() {
|
|
89 // return memory to c_heap.
|
|
90 delete _pops;
|
|
91 }
|
|
92
|
|
93
|
|
94 #ifndef PRODUCT
|
|
95 void JvmtiFramePops::print() {
|
|
96 ResourceMark rm;
|
|
97
|
|
98 int n = _pops->length();
|
|
99 for (int i=0; i<n; i++) {
|
|
100 JvmtiFramePop fp = JvmtiFramePop(_pops->at(i));
|
|
101 tty->print("%d: ", i);
|
|
102 fp.print();
|
|
103 tty->print_cr("");
|
|
104 }
|
|
105 }
|
|
106 #endif
|
|
107
|
|
108 ///////////////////////////////////////////////////////////////
|
|
109 //
|
|
110 // class JvmtiEnvThreadState
|
|
111 //
|
|
112 // Instances of JvmtiEnvThreadState hang off of each JvmtiThreadState,
|
|
113 // one per JvmtiEnv.
|
|
114 //
|
|
115
|
|
116 JvmtiEnvThreadState::JvmtiEnvThreadState(JavaThread *thread, JvmtiEnvBase *env) :
|
|
117 _event_enable() {
|
|
118 _thread = thread;
|
|
119 _env = (JvmtiEnv*)env;
|
|
120 _next = NULL;
|
|
121 _frame_pops = NULL;
|
|
122 _current_bci = 0;
|
|
123 _current_method_id = NULL;
|
|
124 _breakpoint_posted = false;
|
|
125 _single_stepping_posted = false;
|
|
126 _agent_thread_local_storage_data = NULL;
|
|
127 }
|
|
128
|
|
129 JvmtiEnvThreadState::~JvmtiEnvThreadState() {
|
|
130 delete _frame_pops;
|
|
131 _frame_pops = NULL;
|
|
132 }
|
|
133
|
|
134 // Given that a new (potential) event has come in,
|
|
135 // maintain the current JVMTI location on a per-thread per-env basis
|
|
136 // and use it to filter out duplicate events:
|
|
137 // - instruction rewrites
|
|
138 // - breakpoint followed by single step
|
|
139 // - single step at a breakpoint
|
|
140 void JvmtiEnvThreadState::compare_and_set_current_location(methodOop new_method,
|
|
141 address new_location, jvmtiEvent event) {
|
|
142
|
|
143 int new_bci = new_location - new_method->code_base();
|
|
144
|
|
145 // The method is identified and stored as a jmethodID which is safe in this
|
|
146 // case because the class cannot be unloaded while a method is executing.
|
|
147 jmethodID new_method_id = new_method->jmethod_id();
|
|
148
|
|
149 // the last breakpoint or single step was at this same location
|
|
150 if (_current_bci == new_bci && _current_method_id == new_method_id) {
|
|
151 switch (event) {
|
|
152 case JVMTI_EVENT_BREAKPOINT:
|
|
153 // Repeat breakpoint is complicated. If we previously posted a breakpoint
|
|
154 // event at this location and if we also single stepped at this location
|
|
155 // then we skip the duplicate breakpoint.
|
|
156 _breakpoint_posted = _breakpoint_posted && _single_stepping_posted;
|
|
157 break;
|
|
158 case JVMTI_EVENT_SINGLE_STEP:
|
|
159 // Repeat single step is easy: just don't post it again.
|
|
160 // If step is pending for popframe then it may not be
|
|
161 // a repeat step. The new_bci and method_id is same as current_bci
|
|
162 // and current method_id after pop and step for recursive calls.
|
|
163 // This has been handled by clearing the location
|
|
164 _single_stepping_posted = true;
|
|
165 break;
|
|
166 default:
|
|
167 assert(false, "invalid event value passed");
|
|
168 break;
|
|
169 }
|
|
170 return;
|
|
171 }
|
|
172
|
|
173 set_current_location(new_method_id, new_bci);
|
|
174 _breakpoint_posted = false;
|
|
175 _single_stepping_posted = false;
|
|
176 }
|
|
177
|
|
178
|
|
179 JvmtiFramePops* JvmtiEnvThreadState::get_frame_pops() {
|
|
180 #ifdef ASSERT
|
|
181 uint32_t debug_bits = 0;
|
|
182 #endif
|
|
183 assert(get_thread() == Thread::current() || JvmtiEnv::is_thread_fully_suspended(get_thread(), false, &debug_bits),
|
|
184 "frame pop data only accessible from same thread or while suspended");
|
|
185
|
|
186 if (_frame_pops == NULL) {
|
|
187 _frame_pops = new JvmtiFramePops();
|
|
188 assert(_frame_pops != NULL, "_frame_pops != NULL");
|
|
189 }
|
|
190 return _frame_pops;
|
|
191 }
|
|
192
|
|
193
|
|
194 bool JvmtiEnvThreadState::has_frame_pops() {
|
|
195 return _frame_pops == NULL? false : (_frame_pops->length() > 0);
|
|
196 }
|
|
197
|
|
198 void JvmtiEnvThreadState::set_frame_pop(int frame_number) {
|
|
199 #ifdef ASSERT
|
|
200 uint32_t debug_bits = 0;
|
|
201 #endif
|
|
202 assert(get_thread() == Thread::current() || JvmtiEnv::is_thread_fully_suspended(get_thread(), false, &debug_bits),
|
|
203 "frame pop data only accessible from same thread or while suspended");
|
|
204 JvmtiFramePop fpop(frame_number);
|
|
205 JvmtiEventController::set_frame_pop(this, fpop);
|
|
206 }
|
|
207
|
|
208
|
|
209 void JvmtiEnvThreadState::clear_frame_pop(int frame_number) {
|
|
210 #ifdef ASSERT
|
|
211 uint32_t debug_bits = 0;
|
|
212 #endif
|
|
213 assert(get_thread() == Thread::current() || JvmtiEnv::is_thread_fully_suspended(get_thread(), false, &debug_bits),
|
|
214 "frame pop data only accessible from same thread or while suspended");
|
|
215 JvmtiFramePop fpop(frame_number);
|
|
216 JvmtiEventController::clear_frame_pop(this, fpop);
|
|
217 }
|
|
218
|
|
219
|
|
220 void JvmtiEnvThreadState::clear_to_frame_pop(int frame_number) {
|
|
221 #ifdef ASSERT
|
|
222 uint32_t debug_bits = 0;
|
|
223 #endif
|
|
224 assert(get_thread() == Thread::current() || JvmtiEnv::is_thread_fully_suspended(get_thread(), false, &debug_bits),
|
|
225 "frame pop data only accessible from same thread or while suspended");
|
|
226 JvmtiFramePop fpop(frame_number);
|
|
227 JvmtiEventController::clear_to_frame_pop(this, fpop);
|
|
228 }
|
|
229
|
|
230
|
|
231 bool JvmtiEnvThreadState::is_frame_pop(int cur_frame_number) {
|
|
232 #ifdef ASSERT
|
|
233 uint32_t debug_bits = 0;
|
|
234 #endif
|
|
235 assert(get_thread() == Thread::current() || JvmtiEnv::is_thread_fully_suspended(get_thread(), false, &debug_bits),
|
|
236 "frame pop data only accessible from same thread or while suspended");
|
|
237 if (!get_thread()->is_interp_only_mode() || _frame_pops == NULL) {
|
|
238 return false;
|
|
239 }
|
|
240 JvmtiFramePop fp(cur_frame_number);
|
|
241 return get_frame_pops()->contains(fp);
|
|
242 }
|
|
243
|
|
244
|
|
245 class VM_GetCurrentLocation : public VM_Operation {
|
|
246 private:
|
|
247 JavaThread *_thread;
|
|
248 jmethodID _method_id;
|
|
249 int _bci;
|
|
250
|
|
251 public:
|
|
252 VM_GetCurrentLocation(JavaThread *thread) {
|
|
253 _thread = thread;
|
|
254 }
|
|
255 VMOp_Type type() const { return VMOp_GetCurrentLocation; }
|
|
256 void doit() {
|
|
257 ResourceMark rmark; // _thread != Thread::current()
|
|
258 RegisterMap rm(_thread, false);
|
|
259 javaVFrame* vf = _thread->last_java_vframe(&rm);
|
|
260 assert(vf != NULL, "must have last java frame");
|
|
261 methodOop method = vf->method();
|
|
262 _method_id = method->jmethod_id();
|
|
263 _bci = vf->bci();
|
|
264 }
|
|
265 void get_current_location(jmethodID *method_id, int *bci) {
|
|
266 *method_id = _method_id;
|
|
267 *bci = _bci;
|
|
268 }
|
|
269 };
|
|
270
|
|
271 void JvmtiEnvThreadState::reset_current_location(jvmtiEvent event_type, bool enabled) {
|
|
272 assert(event_type == JVMTI_EVENT_SINGLE_STEP || event_type == JVMTI_EVENT_BREAKPOINT,
|
|
273 "must be single-step or breakpoint event");
|
|
274
|
|
275 // Current location is used to detect the following:
|
|
276 // 1) a breakpoint event followed by single-stepping to the same bci
|
|
277 // 2) single-step to a bytecode that will be transformed to a fast version
|
|
278 // We skip to avoid posting the duplicate single-stepping event.
|
|
279
|
|
280 // If single-stepping is disabled, clear current location so that
|
|
281 // single-stepping to the same method and bcp at a later time will be
|
|
282 // detected if single-stepping is enabled at that time (see 4388912).
|
|
283
|
|
284 // If single-stepping is enabled, set the current location to the
|
|
285 // current method and bcp. This covers the following type of case,
|
|
286 // e.g., the debugger stepi command:
|
|
287 // - bytecode single stepped
|
|
288 // - SINGLE_STEP event posted and SINGLE_STEP event disabled
|
|
289 // - SINGLE_STEP event reenabled
|
|
290 // - bytecode rewritten to fast version
|
|
291
|
|
292 // If breakpoint event is disabled, clear current location only if
|
|
293 // single-stepping is not enabled. Otherwise, keep the thread location
|
|
294 // to detect any duplicate events.
|
|
295
|
|
296 if (enabled) {
|
|
297 // If enabling breakpoint, no need to reset.
|
|
298 // Can't do anything if empty stack.
|
|
299 if (event_type == JVMTI_EVENT_SINGLE_STEP && _thread->has_last_Java_frame()) {
|
|
300 jmethodID method_id;
|
|
301 int bci;
|
|
302 // The java thread stack may not be walkable for a running thread
|
|
303 // so get current location at safepoint.
|
|
304 VM_GetCurrentLocation op(_thread);
|
|
305 VMThread::execute(&op);
|
|
306 op.get_current_location(&method_id, &bci);
|
|
307 set_current_location(method_id, bci);
|
|
308 }
|
|
309 } else if (event_type == JVMTI_EVENT_SINGLE_STEP || !is_enabled(JVMTI_EVENT_SINGLE_STEP)) {
|
|
310 // If this is to disable breakpoint, also check if single-step is not enabled
|
|
311 clear_current_location();
|
|
312 }
|
|
313 }
|