1/*
2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#include "precompiled.hpp"
26#include "classfile/systemDictionary.hpp"
27#include "interpreter/interpreter.hpp"
28#include "jvmtifiles/jvmtiEnv.hpp"
29#include "memory/resourceArea.hpp"
30#include "prims/jvmtiEnvThreadState.hpp"
31#include "prims/jvmtiEventController.inline.hpp"
32#include "prims/jvmtiImpl.hpp"
33#include "runtime/handles.hpp"
34#include "runtime/handles.inline.hpp"
35#include "runtime/interfaceSupport.hpp"
36#include "runtime/javaCalls.hpp"
37#include "runtime/signature.hpp"
38#include "runtime/vframe.hpp"
39#include "runtime/vm_operations.hpp"
40
41
42///////////////////////////////////////////////////////////////
43//
44// class JvmtiFramePop
45//
46
47#ifndef PRODUCT
48void JvmtiFramePop::print() {
49  tty->print_cr("_frame_number=%d", _frame_number);
50}
51#endif
52
53
54///////////////////////////////////////////////////////////////
55//
56// class JvmtiFramePops - private methods
57//
58
59void
60JvmtiFramePops::set(JvmtiFramePop& fp) {
61  if (_pops->find(fp.frame_number()) < 0) {
62    _pops->append(fp.frame_number());
63  }
64}
65
66
67void
68JvmtiFramePops::clear(JvmtiFramePop& fp) {
69  assert(_pops->length() > 0, "No more frame pops");
70
71  _pops->remove(fp.frame_number());
72}
73
74
75int
76JvmtiFramePops::clear_to(JvmtiFramePop& fp) {
77  int cleared = 0;
78  int index = 0;
79  while (index < _pops->length()) {
80    JvmtiFramePop pop = JvmtiFramePop(_pops->at(index));
81    if (pop.above_on_stack(fp)) {
82      _pops->remove_at(index);
83      ++cleared;
84    } else {
85      ++index;
86    }
87  }
88  return cleared;
89}
90
91
92///////////////////////////////////////////////////////////////
93//
94// class JvmtiFramePops - public methods
95//
96
97JvmtiFramePops::JvmtiFramePops() {
98  _pops = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<int> (2, true);
99}
100
101JvmtiFramePops::~JvmtiFramePops() {
102  // return memory to c_heap.
103  delete _pops;
104}
105
106
107#ifndef PRODUCT
108void JvmtiFramePops::print() {
109  ResourceMark rm;
110
111  int n = _pops->length();
112  for (int i=0; i<n; i++) {
113    JvmtiFramePop fp = JvmtiFramePop(_pops->at(i));
114    tty->print("%d: ", i);
115    fp.print();
116    tty->cr();
117  }
118}
119#endif
120
121///////////////////////////////////////////////////////////////
122//
123// class JvmtiEnvThreadState
124//
125// Instances of JvmtiEnvThreadState hang off of each JvmtiThreadState,
126// one per JvmtiEnv.
127//
128
129JvmtiEnvThreadState::JvmtiEnvThreadState(JavaThread *thread, JvmtiEnvBase *env) :
130  _event_enable() {
131  _thread                 = thread;
132  _env                    = (JvmtiEnv*)env;
133  _next                   = NULL;
134  _frame_pops             = NULL;
135  _current_bci            = 0;
136  _current_method_id      = NULL;
137  _breakpoint_posted      = false;
138  _single_stepping_posted = false;
139  _agent_thread_local_storage_data = NULL;
140}
141
142JvmtiEnvThreadState::~JvmtiEnvThreadState()   {
143  delete _frame_pops;
144  _frame_pops = NULL;
145}
146
147// Given that a new (potential) event has come in,
148// maintain the current JVMTI location on a per-thread per-env basis
149// and use it to filter out duplicate events:
150// - instruction rewrites
151// - breakpoint followed by single step
152// - single step at a breakpoint
153void JvmtiEnvThreadState::compare_and_set_current_location(Method* new_method,
154                                                           address new_location, jvmtiEvent event) {
155
156  int new_bci = new_location - new_method->code_base();
157
158  // The method is identified and stored as a jmethodID which is safe in this
159  // case because the class cannot be unloaded while a method is executing.
160  jmethodID new_method_id = new_method->jmethod_id();
161
162  // the last breakpoint or single step was at this same location
163  if (_current_bci == new_bci && _current_method_id == new_method_id) {
164    switch (event) {
165    case JVMTI_EVENT_BREAKPOINT:
166      // Repeat breakpoint is complicated. If we previously posted a breakpoint
167      // event at this location and if we also single stepped at this location
168      // then we skip the duplicate breakpoint.
169      _breakpoint_posted = _breakpoint_posted && _single_stepping_posted;
170      break;
171    case JVMTI_EVENT_SINGLE_STEP:
172      // Repeat single step is easy: just don't post it again.
173      // If step is pending for popframe then it may not be
174      // a repeat step. The new_bci and method_id is same as current_bci
175      // and current method_id after pop and step for recursive calls.
176      // This has been handled by clearing the location
177      _single_stepping_posted = true;
178      break;
179    default:
180      assert(false, "invalid event value passed");
181      break;
182    }
183    return;
184  }
185
186  set_current_location(new_method_id, new_bci);
187  _breakpoint_posted = false;
188  _single_stepping_posted = false;
189}
190
191
192JvmtiFramePops* JvmtiEnvThreadState::get_frame_pops() {
193  assert(get_thread() == Thread::current() || SafepointSynchronize::is_at_safepoint(),
194         "frame pop data only accessible from same thread or at safepoint");
195  if (_frame_pops == NULL) {
196    _frame_pops = new JvmtiFramePops();
197    assert(_frame_pops != NULL, "_frame_pops != NULL");
198  }
199  return _frame_pops;
200}
201
202
203bool JvmtiEnvThreadState::has_frame_pops() {
204  return _frame_pops == NULL? false : (_frame_pops->length() > 0);
205}
206
207void JvmtiEnvThreadState::set_frame_pop(int frame_number) {
208  assert(get_thread() == Thread::current() || SafepointSynchronize::is_at_safepoint(),
209         "frame pop data only accessible from same thread or at safepoint");
210  JvmtiFramePop fpop(frame_number);
211  JvmtiEventController::set_frame_pop(this, fpop);
212}
213
214
215void JvmtiEnvThreadState::clear_frame_pop(int frame_number) {
216  assert(get_thread() == Thread::current() || SafepointSynchronize::is_at_safepoint(),
217         "frame pop data only accessible from same thread or at safepoint");
218  JvmtiFramePop fpop(frame_number);
219  JvmtiEventController::clear_frame_pop(this, fpop);
220}
221
222
223void JvmtiEnvThreadState::clear_to_frame_pop(int frame_number)  {
224  assert(get_thread() == Thread::current() || SafepointSynchronize::is_at_safepoint(),
225         "frame pop data only accessible from same thread or at safepoint");
226  JvmtiFramePop fpop(frame_number);
227  JvmtiEventController::clear_to_frame_pop(this, fpop);
228}
229
230
231bool JvmtiEnvThreadState::is_frame_pop(int cur_frame_number) {
232  assert(get_thread() == Thread::current() || SafepointSynchronize::is_at_safepoint(),
233         "frame pop data only accessible from same thread or at safepoint");
234  if (!get_thread()->is_interp_only_mode() || _frame_pops == NULL) {
235    return false;
236  }
237  JvmtiFramePop fp(cur_frame_number);
238  return get_frame_pops()->contains(fp);
239}
240
241
242class VM_GetCurrentLocation : public VM_Operation {
243 private:
244   JavaThread *_thread;
245   jmethodID _method_id;
246   int _bci;
247
248 public:
249  VM_GetCurrentLocation(JavaThread *thread) {
250     _thread = thread;
251   }
252  VMOp_Type type() const { return VMOp_GetCurrentLocation; }
253  void doit() {
254    ResourceMark rmark; // _thread != Thread::current()
255    RegisterMap rm(_thread, false);
256    // There can be a race condition between a VM_Operation reaching a safepoint
257    // and the target thread exiting from Java execution.
258    // We must recheck the last Java frame still exists.
259    if (!_thread->is_exiting() && _thread->has_last_Java_frame()) {
260      javaVFrame* vf = _thread->last_java_vframe(&rm);
261      assert(vf != NULL, "must have last java frame");
262      Method* method = vf->method();
263      _method_id = method->jmethod_id();
264      _bci = vf->bci();
265    } else {
266      // Clear current location as the target thread has no Java frames anymore.
267      _method_id = (jmethodID)NULL;
268      _bci = 0;
269    }
270  }
271  void get_current_location(jmethodID *method_id, int *bci) {
272    *method_id = _method_id;
273    *bci = _bci;
274  }
275};
276
277void JvmtiEnvThreadState::reset_current_location(jvmtiEvent event_type, bool enabled) {
278  assert(event_type == JVMTI_EVENT_SINGLE_STEP || event_type == JVMTI_EVENT_BREAKPOINT,
279         "must be single-step or breakpoint event");
280
281  // Current location is used to detect the following:
282  // 1) a breakpoint event followed by single-stepping to the same bci
283  // 2) single-step to a bytecode that will be transformed to a fast version
284  // We skip to avoid posting the duplicate single-stepping event.
285
286  // If single-stepping is disabled, clear current location so that
287  // single-stepping to the same method and bcp at a later time will be
288  // detected if single-stepping is enabled at that time (see 4388912).
289
290  // If single-stepping is enabled, set the current location to the
291  // current method and bcp. This covers the following type of case,
292  // e.g., the debugger stepi command:
293  // - bytecode single stepped
294  // - SINGLE_STEP event posted and SINGLE_STEP event disabled
295  // - SINGLE_STEP event reenabled
296  // - bytecode rewritten to fast version
297
298  // If breakpoint event is disabled, clear current location only if
299  // single-stepping is not enabled.  Otherwise, keep the thread location
300  // to detect any duplicate events.
301
302  if (enabled) {
303    // If enabling breakpoint, no need to reset.
304    // Can't do anything if empty stack.
305    if (event_type == JVMTI_EVENT_SINGLE_STEP && _thread->has_last_Java_frame()) {
306      jmethodID method_id;
307      int bci;
308      // The java thread stack may not be walkable for a running thread
309      // so get current location at safepoint.
310      VM_GetCurrentLocation op(_thread);
311      VMThread::execute(&op);
312      op.get_current_location(&method_id, &bci);
313      set_current_location(method_id, bci);
314    }
315  } else if (event_type == JVMTI_EVENT_SINGLE_STEP || !is_enabled(JVMTI_EVENT_SINGLE_STEP)) {
316    // If this is to disable breakpoint, also check if single-step is not enabled
317    clear_current_location();
318  }
319}
320