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