1 /*
   2  * Copyright (c) 2003, 2019, 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/symbolTable.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "interpreter/interpreter.hpp"
  29 #include "interpreter/oopMapCache.hpp"
  30 #include "jvmtifiles/jvmtiEnv.hpp"
  31 #include "logging/log.hpp"
  32 #include "logging/logStream.hpp"
  33 #include "memory/allocation.inline.hpp"
  34 #include "memory/resourceArea.hpp"
  35 #include "oops/instanceKlass.hpp"
  36 #include "oops/oop.inline.hpp"
  37 #include "prims/jvmtiAgentThread.hpp"
  38 #include "prims/jvmtiEventController.inline.hpp"
  39 #include "prims/jvmtiImpl.hpp"
  40 #include "prims/jvmtiRedefineClasses.hpp"
  41 #include "runtime/atomic.hpp"
  42 #include "runtime/continuation.hpp"
  43 #include "runtime/deoptimization.hpp"
  44 #include "runtime/frame.inline.hpp"
  45 #include "runtime/handles.inline.hpp"
  46 #include "runtime/interfaceSupport.inline.hpp"
  47 #include "runtime/javaCalls.hpp"
  48 #include "runtime/os.hpp"
  49 #include "runtime/serviceThread.hpp"
  50 #include "runtime/signature.hpp"
  51 #include "runtime/thread.inline.hpp"
  52 #include "runtime/threadSMR.hpp"
  53 #include "runtime/vframe.hpp"
  54 #include "runtime/vframe_hp.hpp"
  55 #include "runtime/vmOperations.hpp"
  56 #include "utilities/exceptions.hpp"
  57 
  58 //
  59 // class JvmtiAgentThread
  60 //
  61 // JavaThread used to wrap a thread started by an agent
  62 // using the JVMTI method RunAgentThread.
  63 //
  64 
  65 JvmtiAgentThread::JvmtiAgentThread(JvmtiEnv* env, jvmtiStartFunction start_fn, const void *start_arg)
  66     : JavaThread(start_function_wrapper) {
  67     _env = env;
  68     _start_fn = start_fn;
  69     _start_arg = start_arg;
  70 }
  71 
  72 void
  73 JvmtiAgentThread::start_function_wrapper(JavaThread *thread, TRAPS) {
  74     // It is expected that any Agent threads will be created as
  75     // Java Threads.  If this is the case, notification of the creation
  76     // of the thread is given in JavaThread::thread_main().
  77     assert(thread->is_Java_thread(), "debugger thread should be a Java Thread");
  78     assert(thread == JavaThread::current(), "sanity check");
  79 
  80     JvmtiAgentThread *dthread = (JvmtiAgentThread *)thread;
  81     dthread->call_start_function();
  82 }
  83 
  84 void
  85 JvmtiAgentThread::call_start_function() {
  86     ThreadToNativeFromVM transition(this);
  87     _start_fn(_env->jvmti_external(), jni_environment(), (void*)_start_arg);
  88 }
  89 
  90 
  91 //
  92 // class GrowableCache - private methods
  93 //
  94 
  95 void GrowableCache::recache() {
  96   int len = _elements->length();
  97 
  98   FREE_C_HEAP_ARRAY(address, _cache);
  99   _cache = NEW_C_HEAP_ARRAY(address,len+1, mtInternal);
 100 
 101   for (int i=0; i<len; i++) {
 102     _cache[i] = _elements->at(i)->getCacheValue();
 103     //
 104     // The cache entry has gone bad. Without a valid frame pointer
 105     // value, the entry is useless so we simply delete it in product
 106     // mode. The call to remove() will rebuild the cache again
 107     // without the bad entry.
 108     //
 109     if (_cache[i] == NULL) {
 110       assert(false, "cannot recache NULL elements");
 111       remove(i);
 112       return;
 113     }
 114   }
 115   _cache[len] = NULL;
 116 
 117   _listener_fun(_this_obj,_cache);
 118 }
 119 
 120 bool GrowableCache::equals(void* v, GrowableElement *e2) {
 121   GrowableElement *e1 = (GrowableElement *) v;
 122   assert(e1 != NULL, "e1 != NULL");
 123   assert(e2 != NULL, "e2 != NULL");
 124 
 125   return e1->equals(e2);
 126 }
 127 
 128 //
 129 // class GrowableCache - public methods
 130 //
 131 
 132 GrowableCache::GrowableCache() {
 133   _this_obj       = NULL;
 134   _listener_fun   = NULL;
 135   _elements       = NULL;
 136   _cache          = NULL;
 137 }
 138 
 139 GrowableCache::~GrowableCache() {
 140   clear();
 141   delete _elements;
 142   FREE_C_HEAP_ARRAY(address, _cache);
 143 }
 144 
 145 void GrowableCache::initialize(void *this_obj, void listener_fun(void *, address*) ) {
 146   _this_obj       = this_obj;
 147   _listener_fun   = listener_fun;
 148   _elements       = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<GrowableElement*>(5,true);
 149   recache();
 150 }
 151 
 152 // number of elements in the collection
 153 int GrowableCache::length() {
 154   return _elements->length();
 155 }
 156 
 157 // get the value of the index element in the collection
 158 GrowableElement* GrowableCache::at(int index) {
 159   GrowableElement *e = (GrowableElement *) _elements->at(index);
 160   assert(e != NULL, "e != NULL");
 161   return e;
 162 }
 163 
 164 int GrowableCache::find(GrowableElement* e) {
 165   return _elements->find(e, GrowableCache::equals);
 166 }
 167 
 168 // append a copy of the element to the end of the collection
 169 void GrowableCache::append(GrowableElement* e) {
 170   GrowableElement *new_e = e->clone();
 171   _elements->append(new_e);
 172   recache();
 173 }
 174 
 175 // insert a copy of the element using lessthan()
 176 void GrowableCache::insert(GrowableElement* e) {
 177   GrowableElement *new_e = e->clone();
 178   _elements->append(new_e);
 179 
 180   int n = length()-2;
 181   for (int i=n; i>=0; i--) {
 182     GrowableElement *e1 = _elements->at(i);
 183     GrowableElement *e2 = _elements->at(i+1);
 184     if (e2->lessThan(e1)) {
 185       _elements->at_put(i+1, e1);
 186       _elements->at_put(i,   e2);
 187     }
 188   }
 189 
 190   recache();
 191 }
 192 
 193 // remove the element at index
 194 void GrowableCache::remove (int index) {
 195   GrowableElement *e = _elements->at(index);
 196   assert(e != NULL, "e != NULL");
 197   _elements->remove(e);
 198   delete e;
 199   recache();
 200 }
 201 
 202 // clear out all elements, release all heap space and
 203 // let our listener know that things have changed.
 204 void GrowableCache::clear() {
 205   int len = _elements->length();
 206   for (int i=0; i<len; i++) {
 207     delete _elements->at(i);
 208   }
 209   _elements->clear();
 210   recache();
 211 }
 212 
 213 void GrowableCache::oops_do(OopClosure* f) {
 214   int len = _elements->length();
 215   for (int i=0; i<len; i++) {
 216     GrowableElement *e = _elements->at(i);
 217     e->oops_do(f);
 218   }
 219 }
 220 
 221 void GrowableCache::metadata_do(void f(Metadata*)) {
 222   int len = _elements->length();
 223   for (int i=0; i<len; i++) {
 224     GrowableElement *e = _elements->at(i);
 225     e->metadata_do(f);
 226   }
 227 }
 228 
 229 //
 230 // class JvmtiBreakpoint
 231 //
 232 
 233 JvmtiBreakpoint::JvmtiBreakpoint() {
 234   _method = NULL;
 235   _bci    = 0;
 236   _class_holder = NULL;
 237 }
 238 
 239 JvmtiBreakpoint::JvmtiBreakpoint(Method* m_method, jlocation location) {
 240   _method        = m_method;
 241   _class_holder  = _method->method_holder()->klass_holder();
 242 #ifdef CHECK_UNHANDLED_OOPS
 243   // _class_holder can't be wrapped in a Handle, because JvmtiBreakpoints are
 244   // sometimes allocated on the heap.
 245   //
 246   // The code handling JvmtiBreakpoints allocated on the stack can't be
 247   // interrupted by a GC until _class_holder is reachable by the GC via the
 248   // oops_do method.
 249   Thread::current()->allow_unhandled_oop(&_class_holder);
 250 #endif // CHECK_UNHANDLED_OOPS
 251   assert(_method != NULL, "_method != NULL");
 252   _bci           = (int) location;
 253   assert(_bci >= 0, "_bci >= 0");
 254 }
 255 
 256 void JvmtiBreakpoint::copy(JvmtiBreakpoint& bp) {
 257   _method   = bp._method;
 258   _bci      = bp._bci;
 259   _class_holder = bp._class_holder;
 260 }
 261 
 262 bool JvmtiBreakpoint::lessThan(JvmtiBreakpoint& bp) {
 263   Unimplemented();
 264   return false;
 265 }
 266 
 267 bool JvmtiBreakpoint::equals(JvmtiBreakpoint& bp) {
 268   return _method   == bp._method
 269     &&   _bci      == bp._bci;
 270 }
 271 
 272 bool JvmtiBreakpoint::is_valid() {
 273   // class loader can be NULL
 274   return _method != NULL &&
 275          _bci >= 0;
 276 }
 277 
 278 address JvmtiBreakpoint::getBcp() const {
 279   return _method->bcp_from(_bci);
 280 }
 281 
 282 void JvmtiBreakpoint::each_method_version_do(method_action meth_act) {
 283   ((Method*)_method->*meth_act)(_bci);
 284 
 285   // add/remove breakpoint to/from versions of the method that are EMCP.
 286   Thread *thread = Thread::current();
 287   InstanceKlass* ik = _method->method_holder();
 288   Symbol* m_name = _method->name();
 289   Symbol* m_signature = _method->signature();
 290 
 291   // search previous versions if they exist
 292   for (InstanceKlass* pv_node = ik->previous_versions();
 293        pv_node != NULL;
 294        pv_node = pv_node->previous_versions()) {
 295     Array<Method*>* methods = pv_node->methods();
 296 
 297     for (int i = methods->length() - 1; i >= 0; i--) {
 298       Method* method = methods->at(i);
 299       // Only set breakpoints in running EMCP methods.
 300       if (method->is_running_emcp() &&
 301           method->name() == m_name &&
 302           method->signature() == m_signature) {
 303         ResourceMark rm;
 304         log_debug(redefine, class, breakpoint)
 305           ("%sing breakpoint in %s(%s)", meth_act == &Method::set_breakpoint ? "sett" : "clear",
 306            method->name()->as_C_string(), method->signature()->as_C_string());
 307         (method->*meth_act)(_bci);
 308         break;
 309       }
 310     }
 311   }
 312 }
 313 
 314 void JvmtiBreakpoint::set() {
 315   each_method_version_do(&Method::set_breakpoint);
 316 }
 317 
 318 void JvmtiBreakpoint::clear() {
 319   each_method_version_do(&Method::clear_breakpoint);
 320 }
 321 
 322 void JvmtiBreakpoint::print_on(outputStream* out) const {
 323 #ifndef PRODUCT
 324   ResourceMark rm;
 325   const char *class_name  = (_method == NULL) ? "NULL" : _method->klass_name()->as_C_string();
 326   const char *method_name = (_method == NULL) ? "NULL" : _method->name()->as_C_string();
 327   out->print("Breakpoint(%s,%s,%d,%p)", class_name, method_name, _bci, getBcp());
 328 #endif
 329 }
 330 
 331 
 332 //
 333 // class VM_ChangeBreakpoints
 334 //
 335 // Modify the Breakpoints data structure at a safepoint
 336 //
 337 
 338 void VM_ChangeBreakpoints::doit() {
 339   switch (_operation) {
 340   case SET_BREAKPOINT:
 341     _breakpoints->set_at_safepoint(*_bp);
 342     break;
 343   case CLEAR_BREAKPOINT:
 344     _breakpoints->clear_at_safepoint(*_bp);
 345     break;
 346   default:
 347     assert(false, "Unknown operation");
 348   }
 349 }
 350 
 351 void VM_ChangeBreakpoints::oops_do(OopClosure* f) {
 352   // The JvmtiBreakpoints in _breakpoints will be visited via
 353   // JvmtiExport::oops_do.
 354   if (_bp != NULL) {
 355     _bp->oops_do(f);
 356   }
 357 }
 358 
 359 void VM_ChangeBreakpoints::metadata_do(void f(Metadata*)) {
 360   // Walk metadata in breakpoints to keep from being deallocated with RedefineClasses
 361   if (_bp != NULL) {
 362     _bp->metadata_do(f);
 363   }
 364 }
 365 
 366 //
 367 // class JvmtiBreakpoints
 368 //
 369 // a JVMTI internal collection of JvmtiBreakpoint
 370 //
 371 
 372 JvmtiBreakpoints::JvmtiBreakpoints(void listener_fun(void *,address *)) {
 373   _bps.initialize(this,listener_fun);
 374 }
 375 
 376 JvmtiBreakpoints:: ~JvmtiBreakpoints() {}
 377 
 378 void  JvmtiBreakpoints::oops_do(OopClosure* f) {
 379   _bps.oops_do(f);
 380 }
 381 
 382 void  JvmtiBreakpoints::metadata_do(void f(Metadata*)) {
 383   _bps.metadata_do(f);
 384 }
 385 
 386 void JvmtiBreakpoints::print() {
 387 #ifndef PRODUCT
 388   LogTarget(Trace, jvmti) log;
 389   LogStream log_stream(log);
 390 
 391   int n = _bps.length();
 392   for (int i=0; i<n; i++) {
 393     JvmtiBreakpoint& bp = _bps.at(i);
 394     log_stream.print("%d: ", i);
 395     bp.print_on(&log_stream);
 396     log_stream.cr();
 397   }
 398 #endif
 399 }
 400 
 401 
 402 void JvmtiBreakpoints::set_at_safepoint(JvmtiBreakpoint& bp) {
 403   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 404 
 405   int i = _bps.find(bp);
 406   if (i == -1) {
 407     _bps.append(bp);
 408     bp.set();
 409   }
 410 }
 411 
 412 void JvmtiBreakpoints::clear_at_safepoint(JvmtiBreakpoint& bp) {
 413   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 414 
 415   int i = _bps.find(bp);
 416   if (i != -1) {
 417     _bps.remove(i);
 418     bp.clear();
 419   }
 420 }
 421 
 422 int JvmtiBreakpoints::length() { return _bps.length(); }
 423 
 424 int JvmtiBreakpoints::set(JvmtiBreakpoint& bp) {
 425   if ( _bps.find(bp) != -1) {
 426      return JVMTI_ERROR_DUPLICATE;
 427   }
 428   VM_ChangeBreakpoints set_breakpoint(VM_ChangeBreakpoints::SET_BREAKPOINT, &bp);
 429   VMThread::execute(&set_breakpoint);
 430   return JVMTI_ERROR_NONE;
 431 }
 432 
 433 int JvmtiBreakpoints::clear(JvmtiBreakpoint& bp) {
 434   if ( _bps.find(bp) == -1) {
 435      return JVMTI_ERROR_NOT_FOUND;
 436   }
 437 
 438   VM_ChangeBreakpoints clear_breakpoint(VM_ChangeBreakpoints::CLEAR_BREAKPOINT, &bp);
 439   VMThread::execute(&clear_breakpoint);
 440   return JVMTI_ERROR_NONE;
 441 }
 442 
 443 void JvmtiBreakpoints::clearall_in_class_at_safepoint(Klass* klass) {
 444   bool changed = true;
 445   // We are going to run thru the list of bkpts
 446   // and delete some.  This deletion probably alters
 447   // the list in some implementation defined way such
 448   // that when we delete entry i, the next entry might
 449   // no longer be at i+1.  To be safe, each time we delete
 450   // an entry, we'll just start again from the beginning.
 451   // We'll stop when we make a pass thru the whole list without
 452   // deleting anything.
 453   while (changed) {
 454     int len = _bps.length();
 455     changed = false;
 456     for (int i = 0; i < len; i++) {
 457       JvmtiBreakpoint& bp = _bps.at(i);
 458       if (bp.method()->method_holder() == klass) {
 459         bp.clear();
 460         _bps.remove(i);
 461         // This changed 'i' so we have to start over.
 462         changed = true;
 463         break;
 464       }
 465     }
 466   }
 467 }
 468 
 469 //
 470 // class JvmtiCurrentBreakpoints
 471 //
 472 
 473 JvmtiBreakpoints *JvmtiCurrentBreakpoints::_jvmti_breakpoints  = NULL;
 474 address *         JvmtiCurrentBreakpoints::_breakpoint_list    = NULL;
 475 
 476 
 477 JvmtiBreakpoints& JvmtiCurrentBreakpoints::get_jvmti_breakpoints() {
 478   if (_jvmti_breakpoints != NULL) return (*_jvmti_breakpoints);
 479   _jvmti_breakpoints = new JvmtiBreakpoints(listener_fun);
 480   assert(_jvmti_breakpoints != NULL, "_jvmti_breakpoints != NULL");
 481   return (*_jvmti_breakpoints);
 482 }
 483 
 484 void  JvmtiCurrentBreakpoints::listener_fun(void *this_obj, address *cache) {
 485   JvmtiBreakpoints *this_jvmti = (JvmtiBreakpoints *) this_obj;
 486   assert(this_jvmti != NULL, "this_jvmti != NULL");
 487 
 488   debug_only(int n = this_jvmti->length(););
 489   assert(cache[n] == NULL, "cache must be NULL terminated");
 490 
 491   set_breakpoint_list(cache);
 492 }
 493 
 494 
 495 void JvmtiCurrentBreakpoints::oops_do(OopClosure* f) {
 496   if (_jvmti_breakpoints != NULL) {
 497     _jvmti_breakpoints->oops_do(f);
 498   }
 499 }
 500 
 501 void JvmtiCurrentBreakpoints::metadata_do(void f(Metadata*)) {
 502   if (_jvmti_breakpoints != NULL) {
 503     _jvmti_breakpoints->metadata_do(f);
 504   }
 505 }
 506 
 507 ///////////////////////////////////////////////////////////////
 508 //
 509 // class VM_GetOrSetLocal
 510 //
 511 
 512 // Constructor for non-object getter
 513 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type)
 514   : _thread(thread)
 515   , _calling_thread(NULL)
 516   , _depth(depth)
 517   , _index(index)
 518   , _type(type)
 519   , _jvf(NULL)
 520   , _set(false)
 521   , _result(JVMTI_ERROR_NONE)
 522 {
 523 }
 524 
 525 // Constructor for object or non-object setter
 526 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type, jvalue value)
 527   : _thread(thread)
 528   , _calling_thread(NULL)
 529   , _depth(depth)
 530   , _index(index)
 531   , _type(type)
 532   , _value(value)
 533   , _jvf(NULL)
 534   , _set(true)
 535   , _result(JVMTI_ERROR_NONE)
 536 {
 537 }
 538 
 539 // Constructor for object getter
 540 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth, int index)
 541   : _thread(thread)
 542   , _calling_thread(calling_thread)
 543   , _depth(depth)
 544   , _index(index)
 545   , _type(T_OBJECT)
 546   , _jvf(NULL)
 547   , _set(false)
 548   , _result(JVMTI_ERROR_NONE)
 549 {
 550 }
 551 
 552 vframe *VM_GetOrSetLocal::get_vframe() {
 553   if (!_thread->has_last_Java_frame()) {
 554     return NULL;
 555   }
 556   RegisterMap reg_map(_thread, true, true);
 557   vframe *vf = _thread->last_java_vframe(&reg_map);
 558   int d = 0;
 559   while ((vf != NULL) && (d < _depth)) {
 560     vf = vf->java_sender();
 561     d++;
 562   }
 563   return vf;
 564 }
 565 
 566 javaVFrame *VM_GetOrSetLocal::get_java_vframe() {
 567   vframe* vf = get_vframe();
 568   if (vf == NULL) {
 569     _result = JVMTI_ERROR_NO_MORE_FRAMES;
 570     return NULL;
 571   }
 572   javaVFrame *jvf = (javaVFrame*)vf;
 573 
 574   if (!vf->is_java_frame()) {
 575     _result = JVMTI_ERROR_OPAQUE_FRAME;
 576     return NULL;
 577   }
 578   return jvf;
 579 }
 580 
 581 // Check that the klass is assignable to a type with the given signature.
 582 // Another solution could be to use the function Klass::is_subtype_of(type).
 583 // But the type class can be forced to load/initialize eagerly in such a case.
 584 // This may cause unexpected consequences like CFLH or class-init JVMTI events.
 585 // It is better to avoid such a behavior.
 586 bool VM_GetOrSetLocal::is_assignable(const char* ty_sign, Klass* klass, Thread* thread) {
 587   assert(ty_sign != NULL, "type signature must not be NULL");
 588   assert(thread != NULL, "thread must not be NULL");
 589   assert(klass != NULL, "klass must not be NULL");
 590 
 591   int len = (int) strlen(ty_sign);
 592   if (ty_sign[0] == 'L' && ty_sign[len-1] == ';') { // Need pure class/interface name
 593     ty_sign++;
 594     len -= 2;
 595   }
 596   TempNewSymbol ty_sym = SymbolTable::new_symbol(ty_sign, len);
 597   if (klass->name() == ty_sym) {
 598     return true;
 599   }
 600   // Compare primary supers
 601   int super_depth = klass->super_depth();
 602   int idx;
 603   for (idx = 0; idx < super_depth; idx++) {
 604     if (klass->primary_super_of_depth(idx)->name() == ty_sym) {
 605       return true;
 606     }
 607   }
 608   // Compare secondary supers
 609   const Array<Klass*>* sec_supers = klass->secondary_supers();
 610   for (idx = 0; idx < sec_supers->length(); idx++) {
 611     if (((Klass*) sec_supers->at(idx))->name() == ty_sym) {
 612       return true;
 613     }
 614   }
 615   return false;
 616 }
 617 
 618 // Checks error conditions:
 619 //   JVMTI_ERROR_INVALID_SLOT
 620 //   JVMTI_ERROR_TYPE_MISMATCH
 621 // Returns: 'true' - everything is Ok, 'false' - error code
 622 
 623 bool VM_GetOrSetLocal::check_slot_type_lvt(javaVFrame* jvf) {
 624   Method* method_oop = jvf->method();
 625   if (!method_oop->has_localvariable_table()) {
 626     // Just to check index boundaries
 627     jint extra_slot = (_type == T_LONG || _type == T_DOUBLE) ? 1 : 0;
 628     if (_index < 0 || _index + extra_slot >= method_oop->max_locals()) {
 629       _result = JVMTI_ERROR_INVALID_SLOT;
 630       return false;
 631     }
 632     return true;
 633   }
 634 
 635   jint num_entries = method_oop->localvariable_table_length();
 636   if (num_entries == 0) {
 637     _result = JVMTI_ERROR_INVALID_SLOT;
 638     return false;       // There are no slots
 639   }
 640   int signature_idx = -1;
 641   int vf_bci = jvf->bci();
 642   LocalVariableTableElement* table = method_oop->localvariable_table_start();
 643   for (int i = 0; i < num_entries; i++) {
 644     int start_bci = table[i].start_bci;
 645     int end_bci = start_bci + table[i].length;
 646 
 647     // Here we assume that locations of LVT entries
 648     // with the same slot number cannot be overlapped
 649     if (_index == (jint) table[i].slot && start_bci <= vf_bci && vf_bci <= end_bci) {
 650       signature_idx = (int) table[i].descriptor_cp_index;
 651       break;
 652     }
 653   }
 654   if (signature_idx == -1) {
 655     _result = JVMTI_ERROR_INVALID_SLOT;
 656     return false;       // Incorrect slot index
 657   }
 658   Symbol*   sign_sym  = method_oop->constants()->symbol_at(signature_idx);
 659   const char* signature = (const char *) sign_sym->as_utf8();
 660   BasicType slot_type = char2type(signature[0]);
 661 
 662   switch (slot_type) {
 663   case T_BYTE:
 664   case T_SHORT:
 665   case T_CHAR:
 666   case T_BOOLEAN:
 667     slot_type = T_INT;
 668     break;
 669   case T_ARRAY:
 670     slot_type = T_OBJECT;
 671     break;
 672   default:
 673     break;
 674   };
 675   if (_type != slot_type) {
 676     _result = JVMTI_ERROR_TYPE_MISMATCH;
 677     return false;
 678   }
 679 
 680   jobject jobj = _value.l;
 681   if (_set && slot_type == T_OBJECT && jobj != NULL) { // NULL reference is allowed
 682     // Check that the jobject class matches the return type signature.
 683     JavaThread* cur_thread = JavaThread::current();
 684     HandleMark hm(cur_thread);
 685 
 686     Handle obj(cur_thread, JNIHandles::resolve_external_guard(jobj));
 687     NULL_CHECK(obj, (_result = JVMTI_ERROR_INVALID_OBJECT, false));
 688     Klass* ob_k = obj->klass();
 689     NULL_CHECK(ob_k, (_result = JVMTI_ERROR_INVALID_OBJECT, false));
 690 
 691     if (!is_assignable(signature, ob_k, cur_thread)) {
 692       _result = JVMTI_ERROR_TYPE_MISMATCH;
 693       return false;
 694     }
 695   }
 696   return true;
 697 }
 698 
 699 bool VM_GetOrSetLocal::check_slot_type_no_lvt(javaVFrame* jvf) {
 700   Method* method_oop = jvf->method();
 701   jint extra_slot = (_type == T_LONG || _type == T_DOUBLE) ? 1 : 0;
 702 
 703   if (_index < 0 || _index + extra_slot >= method_oop->max_locals()) {
 704     _result = JVMTI_ERROR_INVALID_SLOT;
 705     return false;
 706   }
 707   StackValueCollection *locals = _jvf->locals();
 708   BasicType slot_type = locals->at(_index)->type();
 709 
 710   if (slot_type == T_CONFLICT) {
 711     _result = JVMTI_ERROR_INVALID_SLOT;
 712     return false;
 713   }
 714   if (extra_slot) {
 715     BasicType extra_slot_type = locals->at(_index + 1)->type();
 716     if (extra_slot_type != T_INT) {
 717       _result = JVMTI_ERROR_INVALID_SLOT;
 718       return false;
 719     }
 720   }
 721   if (_type != slot_type && (_type == T_OBJECT || slot_type != T_INT)) {
 722     _result = JVMTI_ERROR_TYPE_MISMATCH;
 723     return false;
 724   }
 725   return true;
 726 }
 727 
 728 static bool can_be_deoptimized(vframe* vf) {
 729   return (vf->is_compiled_frame() && vf->fr().can_be_deoptimized());
 730 }
 731 
 732 bool VM_GetOrSetLocal::doit_prologue() {
 733   _jvf = get_java_vframe();
 734   NULL_CHECK(_jvf, false);
 735 
 736   if (_set && Continuation::is_frame_in_continuation(_jvf->thread(), _jvf->fr())) {
 737     _result = JVMTI_ERROR_OPAQUE_FRAME; // deferred locals currently unsupported in continuations
 738     return false;
 739   }
 740 
 741   Method* method_oop = _jvf->method();
 742   if (method_oop->is_native()) {
 743     if (getting_receiver() && !method_oop->is_static()) {
 744       return true;
 745     } else {
 746       _result = JVMTI_ERROR_OPAQUE_FRAME;
 747       return false;
 748     }
 749   }
 750 
 751   if (!check_slot_type_no_lvt(_jvf)) {
 752     return false;
 753   }
 754   if (method_oop->has_localvariable_table()) {
 755     return check_slot_type_lvt(_jvf);
 756   }
 757   return true;
 758 }
 759 
 760 void VM_GetOrSetLocal::doit() {
 761   InterpreterOopMap oop_mask;
 762   _jvf->method()->mask_for(_jvf->bci(), &oop_mask);
 763   if (oop_mask.is_dead(_index)) {
 764     // The local can be invalid and uninitialized in the scope of current bci
 765     _result = JVMTI_ERROR_INVALID_SLOT;
 766     return;
 767   }
 768   if (_set) {
 769     // Force deoptimization of frame if compiled because it's
 770     // possible the compiler emitted some locals as constant values,
 771     // meaning they are not mutable.
 772     if (can_be_deoptimized(_jvf)) {
 773 
 774       // Schedule deoptimization so that eventually the local
 775       // update will be written to an interpreter frame.
 776       Deoptimization::deoptimize_frame(_jvf->thread(), _jvf->fr().id());
 777 
 778       // Now store a new value for the local which will be applied
 779       // once deoptimization occurs. Note however that while this
 780       // write is deferred until deoptimization actually happens
 781       // can vframe created after this point will have its locals
 782       // reflecting this update so as far as anyone can see the
 783       // write has already taken place.
 784 
 785       // If we are updating an oop then get the oop from the handle
 786       // since the handle will be long gone by the time the deopt
 787       // happens. The oop stored in the deferred local will be
 788       // gc'd on its own.
 789       if (_type == T_OBJECT) {
 790         _value.l = (jobject) (JNIHandles::resolve_external_guard(_value.l));
 791       }
 792       // Re-read the vframe so we can see that it is deoptimized
 793       // [ Only need because of assert in update_local() ]
 794       _jvf = get_java_vframe();
 795       ((compiledVFrame*)_jvf)->update_local(_type, _index, _value);
 796       return;
 797     }
 798     StackValueCollection *locals = _jvf->locals();
 799     HandleMark hm;
 800 
 801     switch (_type) {
 802       case T_INT:    locals->set_int_at   (_index, _value.i); break;
 803       case T_LONG:   locals->set_long_at  (_index, _value.j); break;
 804       case T_FLOAT:  locals->set_float_at (_index, _value.f); break;
 805       case T_DOUBLE: locals->set_double_at(_index, _value.d); break;
 806       case T_OBJECT: {
 807         Handle ob_h(Thread::current(), JNIHandles::resolve_external_guard(_value.l));
 808         locals->set_obj_at (_index, ob_h);
 809         break;
 810       }
 811       default: ShouldNotReachHere();
 812     }
 813     _jvf->set_locals(locals);
 814   } else {
 815     if (_jvf->method()->is_native() && _jvf->is_compiled_frame()) {
 816       assert(getting_receiver(), "Can only get here when getting receiver");
 817       oop receiver = _jvf->fr().get_native_receiver();
 818       _value.l = JNIHandles::make_local(_calling_thread, receiver);
 819     } else {
 820       StackValueCollection *locals = _jvf->locals();
 821 
 822       switch (_type) {
 823         case T_INT:    _value.i = locals->int_at   (_index);   break;
 824         case T_LONG:   _value.j = locals->long_at  (_index);   break;
 825         case T_FLOAT:  _value.f = locals->float_at (_index);   break;
 826         case T_DOUBLE: _value.d = locals->double_at(_index);   break;
 827         case T_OBJECT: {
 828           // Wrap the oop to be returned in a local JNI handle since
 829           // oops_do() no longer applies after doit() is finished.
 830           oop obj = locals->obj_at(_index)();
 831           _value.l = JNIHandles::make_local(_calling_thread, obj);
 832           break;
 833         }
 834         default: ShouldNotReachHere();
 835       }
 836     }
 837   }
 838 }
 839 
 840 
 841 bool VM_GetOrSetLocal::allow_nested_vm_operations() const {
 842   return true; // May need to deoptimize
 843 }
 844 
 845 
 846 VM_GetReceiver::VM_GetReceiver(
 847     JavaThread* thread, JavaThread* caller_thread, jint depth)
 848     : VM_GetOrSetLocal(thread, caller_thread, depth, 0) {}
 849 
 850 /////////////////////////////////////////////////////////////////////////////////////////
 851 
 852 //
 853 // class JvmtiSuspendControl - see comments in jvmtiImpl.hpp
 854 //
 855 
 856 bool JvmtiSuspendControl::suspend(JavaThread *java_thread) {
 857   // external suspend should have caught suspending a thread twice
 858 
 859   // Immediate suspension required for JPDA back-end so JVMTI agent threads do
 860   // not deadlock due to later suspension on transitions while holding
 861   // raw monitors.  Passing true causes the immediate suspension.
 862   // java_suspend() will catch threads in the process of exiting
 863   // and will ignore them.
 864   java_thread->java_suspend();
 865 
 866   // It would be nice to have the following assertion in all the time,
 867   // but it is possible for a racing resume request to have resumed
 868   // this thread right after we suspended it. Temporarily enable this
 869   // assertion if you are chasing a different kind of bug.
 870   //
 871   // assert(java_lang_Thread::thread(java_thread->threadObj()) == NULL ||
 872   //   java_thread->is_being_ext_suspended(), "thread is not suspended");
 873 
 874   if (java_lang_Thread::thread(java_thread->threadObj()) == NULL) {
 875     // check again because we can get delayed in java_suspend():
 876     // the thread is in process of exiting.
 877     return false;
 878   }
 879 
 880   return true;
 881 }
 882 
 883 bool JvmtiSuspendControl::resume(JavaThread *java_thread) {
 884   // external suspend should have caught resuming a thread twice
 885   assert(java_thread->is_being_ext_suspended(), "thread should be suspended");
 886 
 887   // resume thread
 888   {
 889     // must always grab Threads_lock, see JVM_SuspendThread
 890     MutexLocker ml(Threads_lock);
 891     java_thread->java_resume();
 892   }
 893 
 894   return true;
 895 }
 896 
 897 
 898 void JvmtiSuspendControl::print() {
 899 #ifndef PRODUCT
 900   LogStreamHandle(Trace, jvmti) log_stream;
 901   log_stream.print("Suspended Threads: [");
 902   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thread = jtiwh.next(); ) {
 903 #ifdef JVMTI_TRACE
 904     const char *name   = JvmtiTrace::safe_get_thread_name(thread);
 905 #else
 906     const char *name   = "";
 907 #endif /*JVMTI_TRACE */
 908     log_stream.print("%s(%c ", name, thread->is_being_ext_suspended() ? 'S' : '_');
 909     if (!thread->has_last_Java_frame()) {
 910       log_stream.print("no stack");
 911     }
 912     log_stream.print(") ");
 913   }
 914   log_stream.print_cr("]");
 915 #endif
 916 }
 917 
 918 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_load_event(
 919     nmethod* nm) {
 920   JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_LOAD);
 921   event._event_data.compiled_method_load = nm;
 922   // Keep the nmethod alive until the ServiceThread can process
 923   // this deferred event.
 924   nmethodLocker::lock_nmethod(nm);
 925   return event;
 926 }
 927 
 928 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_unload_event(
 929     nmethod* nm, jmethodID id, const void* code) {
 930   JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_UNLOAD);
 931   event._event_data.compiled_method_unload.nm = nm;
 932   event._event_data.compiled_method_unload.method_id = id;
 933   event._event_data.compiled_method_unload.code_begin = code;
 934   // Keep the nmethod alive until the ServiceThread can process
 935   // this deferred event. This will keep the memory for the
 936   // generated code from being reused too early. We pass
 937   // zombie_ok == true here so that our nmethod that was just
 938   // made into a zombie can be locked.
 939   nmethodLocker::lock_nmethod(nm, true /* zombie_ok */);
 940   return event;
 941 }
 942 
 943 JvmtiDeferredEvent JvmtiDeferredEvent::dynamic_code_generated_event(
 944       const char* name, const void* code_begin, const void* code_end) {
 945   JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_DYNAMIC_CODE_GENERATED);
 946   // Need to make a copy of the name since we don't know how long
 947   // the event poster will keep it around after we enqueue the
 948   // deferred event and return. strdup() failure is handled in
 949   // the post() routine below.
 950   event._event_data.dynamic_code_generated.name = os::strdup(name);
 951   event._event_data.dynamic_code_generated.code_begin = code_begin;
 952   event._event_data.dynamic_code_generated.code_end = code_end;
 953   return event;
 954 }
 955 
 956 void JvmtiDeferredEvent::post() {
 957   assert(ServiceThread::is_service_thread(Thread::current()),
 958          "Service thread must post enqueued events");
 959   switch(_type) {
 960     case TYPE_COMPILED_METHOD_LOAD: {
 961       nmethod* nm = _event_data.compiled_method_load;
 962       JvmtiExport::post_compiled_method_load(nm);
 963       // done with the deferred event so unlock the nmethod
 964       nmethodLocker::unlock_nmethod(nm);
 965       break;
 966     }
 967     case TYPE_COMPILED_METHOD_UNLOAD: {
 968       nmethod* nm = _event_data.compiled_method_unload.nm;
 969       JvmtiExport::post_compiled_method_unload(
 970         _event_data.compiled_method_unload.method_id,
 971         _event_data.compiled_method_unload.code_begin);
 972       // done with the deferred event so unlock the nmethod
 973       nmethodLocker::unlock_nmethod(nm);
 974       break;
 975     }
 976     case TYPE_DYNAMIC_CODE_GENERATED: {
 977       JvmtiExport::post_dynamic_code_generated_internal(
 978         // if strdup failed give the event a default name
 979         (_event_data.dynamic_code_generated.name == NULL)
 980           ? "unknown_code" : _event_data.dynamic_code_generated.name,
 981         _event_data.dynamic_code_generated.code_begin,
 982         _event_data.dynamic_code_generated.code_end);
 983       if (_event_data.dynamic_code_generated.name != NULL) {
 984         // release our copy
 985         os::free((void *)_event_data.dynamic_code_generated.name);
 986       }
 987       break;
 988     }
 989     default:
 990       ShouldNotReachHere();
 991   }
 992 }
 993 
 994 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
 995 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
 996 
 997 bool JvmtiDeferredEventQueue::has_events() {
 998   assert(Service_lock->owned_by_self(), "Must own Service_lock");
 999   return _queue_head != NULL;
1000 }
1001 
1002 void JvmtiDeferredEventQueue::enqueue(const JvmtiDeferredEvent& event) {
1003   assert(Service_lock->owned_by_self(), "Must own Service_lock");
1004 
1005   // Events get added to the end of the queue (and are pulled off the front).
1006   QueueNode* node = new QueueNode(event);
1007   if (_queue_tail == NULL) {
1008     _queue_tail = _queue_head = node;
1009   } else {
1010     assert(_queue_tail->next() == NULL, "Must be the last element in the list");
1011     _queue_tail->set_next(node);
1012     _queue_tail = node;
1013   }
1014 
1015   Service_lock->notify_all();
1016   assert((_queue_head == NULL) == (_queue_tail == NULL),
1017          "Inconsistent queue markers");
1018 }
1019 
1020 JvmtiDeferredEvent JvmtiDeferredEventQueue::dequeue() {
1021   assert(Service_lock->owned_by_self(), "Must own Service_lock");
1022 
1023   assert(_queue_head != NULL, "Nothing to dequeue");
1024 
1025   if (_queue_head == NULL) {
1026     // Just in case this happens in product; it shouldn't but let's not crash
1027     return JvmtiDeferredEvent();
1028   }
1029 
1030   QueueNode* node = _queue_head;
1031   _queue_head = _queue_head->next();
1032   if (_queue_head == NULL) {
1033     _queue_tail = NULL;
1034   }
1035 
1036   assert((_queue_head == NULL) == (_queue_tail == NULL),
1037          "Inconsistent queue markers");
1038 
1039   JvmtiDeferredEvent event = node->event();
1040   delete node;
1041   return event;
1042 }