rev 47862 : imported patch 10.07.open.rebase_20171110.dcubed

   1 /*
   2  * Copyright (c) 2003, 2017, 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 "code/nmethod.hpp"
  28 #include "code/pcDesc.hpp"
  29 #include "code/scopeDesc.hpp"
  30 #include "interpreter/interpreter.hpp"
  31 #include "jvmtifiles/jvmtiEnv.hpp"
  32 #include "logging/log.hpp"
  33 #include "logging/logStream.hpp"
  34 #include "memory/resourceArea.hpp"
  35 #include "oops/objArrayKlass.hpp"
  36 #include "oops/objArrayOop.hpp"
  37 #include "oops/oop.inline.hpp"
  38 #include "prims/jvmtiCodeBlobEvents.hpp"
  39 #include "prims/jvmtiEventController.hpp"
  40 #include "prims/jvmtiEventController.inline.hpp"
  41 #include "prims/jvmtiExport.hpp"
  42 #include "prims/jvmtiImpl.hpp"
  43 #include "prims/jvmtiManageCapabilities.hpp"
  44 #include "prims/jvmtiRawMonitor.hpp"
  45 #include "prims/jvmtiRedefineClasses.hpp"
  46 #include "prims/jvmtiTagMap.hpp"
  47 #include "prims/jvmtiThreadState.inline.hpp"
  48 #include "runtime/arguments.hpp"
  49 #include "runtime/handles.hpp"
  50 #include "runtime/interfaceSupport.hpp"
  51 #include "runtime/javaCalls.hpp"
  52 #include "runtime/objectMonitor.hpp"
  53 #include "runtime/objectMonitor.inline.hpp"
  54 #include "runtime/os.inline.hpp"
  55 #include "runtime/thread.inline.hpp"
  56 #include "runtime/threadSMR.hpp"
  57 #include "runtime/vframe.hpp"
  58 #include "services/serviceUtil.hpp"
  59 #include "utilities/macros.hpp"
  60 #if INCLUDE_ALL_GCS
  61 #include "gc/parallel/psMarkSweep.hpp"
  62 #endif // INCLUDE_ALL_GCS
  63 
  64 #ifdef JVMTI_TRACE
  65 #define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; log_trace(jvmti) out; }
  66 #define EVT_TRIG_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_TRIGGER) != 0) { SafeResourceMark rm; log_trace(jvmti) out; }
  67 #else
  68 #define EVT_TRIG_TRACE(evt,out)
  69 #define EVT_TRACE(evt,out)
  70 #endif
  71 
  72 ///////////////////////////////////////////////////////////////
  73 //
  74 // JvmtiEventTransition
  75 //
  76 // TO DO --
  77 //  more handle purging
  78 
  79 // Use this for JavaThreads and state is  _thread_in_vm.
  80 class JvmtiJavaThreadEventTransition : StackObj {
  81 private:
  82   ResourceMark _rm;
  83   ThreadToNativeFromVM _transition;
  84   HandleMark _hm;
  85 
  86 public:
  87   JvmtiJavaThreadEventTransition(JavaThread *thread) :
  88     _rm(),
  89     _transition(thread),
  90     _hm(thread)  {};
  91 };
  92 
  93 // For JavaThreads which are not in _thread_in_vm state
  94 // and other system threads use this.
  95 class JvmtiThreadEventTransition : StackObj {
  96 private:
  97   ResourceMark _rm;
  98   HandleMark _hm;
  99   JavaThreadState _saved_state;
 100   JavaThread *_jthread;
 101 
 102 public:
 103   JvmtiThreadEventTransition(Thread *thread) : _rm(), _hm() {
 104     if (thread->is_Java_thread()) {
 105        _jthread = (JavaThread *)thread;
 106        _saved_state = _jthread->thread_state();
 107        if (_saved_state == _thread_in_Java) {
 108          ThreadStateTransition::transition_from_java(_jthread, _thread_in_native);
 109        } else {
 110          ThreadStateTransition::transition(_jthread, _saved_state, _thread_in_native);
 111        }
 112     } else {
 113       _jthread = NULL;
 114     }
 115   }
 116 
 117   ~JvmtiThreadEventTransition() {
 118     if (_jthread != NULL)
 119       ThreadStateTransition::transition_from_native(_jthread, _saved_state);
 120   }
 121 };
 122 
 123 
 124 ///////////////////////////////////////////////////////////////
 125 //
 126 // JvmtiEventMark
 127 //
 128 
 129 class JvmtiEventMark : public StackObj {
 130 private:
 131   JavaThread *_thread;
 132   JNIEnv* _jni_env;
 133   JvmtiThreadState::ExceptionState _saved_exception_state;
 134 #if 0
 135   JNIHandleBlock* _hblock;
 136 #endif
 137 
 138 public:
 139   JvmtiEventMark(JavaThread *thread) :  _thread(thread),
 140                                         _jni_env(thread->jni_environment()),
 141                                         _saved_exception_state(JvmtiThreadState::ES_CLEARED) {
 142 #if 0
 143     _hblock = thread->active_handles();
 144     _hblock->clear_thoroughly(); // so we can be safe
 145 #else
 146     // we want to use the code above - but that needs the JNIHandle changes - later...
 147     // for now, steal JNI push local frame code
 148     JvmtiThreadState *state = thread->jvmti_thread_state();
 149     // we are before an event.
 150     // Save current jvmti thread exception state.
 151     if (state != NULL) {
 152       _saved_exception_state = state->get_exception_state();
 153     }
 154 
 155     JNIHandleBlock* old_handles = thread->active_handles();
 156     JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
 157     assert(new_handles != NULL, "should not be NULL");
 158     new_handles->set_pop_frame_link(old_handles);
 159     thread->set_active_handles(new_handles);
 160 #endif
 161     assert(thread == JavaThread::current(), "thread must be current!");
 162     thread->frame_anchor()->make_walkable(thread);
 163   };
 164 
 165   ~JvmtiEventMark() {
 166 #if 0
 167     _hblock->clear(); // for consistency with future correct behavior
 168 #else
 169     // we want to use the code above - but that needs the JNIHandle changes - later...
 170     // for now, steal JNI pop local frame code
 171     JNIHandleBlock* old_handles = _thread->active_handles();
 172     JNIHandleBlock* new_handles = old_handles->pop_frame_link();
 173     assert(new_handles != NULL, "should not be NULL");
 174     _thread->set_active_handles(new_handles);
 175     // Note that we set the pop_frame_link to NULL explicitly, otherwise
 176     // the release_block call will release the blocks.
 177     old_handles->set_pop_frame_link(NULL);
 178     JNIHandleBlock::release_block(old_handles, _thread); // may block
 179 #endif
 180 
 181     JvmtiThreadState* state = _thread->jvmti_thread_state();
 182     // we are continuing after an event.
 183     if (state != NULL) {
 184       // Restore the jvmti thread exception state.
 185       state->restore_exception_state(_saved_exception_state);
 186     }
 187   }
 188 
 189 #if 0
 190   jobject to_jobject(oop obj) { return obj == NULL? NULL : _hblock->allocate_handle_fast(obj); }
 191 #else
 192   // we want to use the code above - but that needs the JNIHandle changes - later...
 193   // for now, use regular make_local
 194   jobject to_jobject(oop obj) { return JNIHandles::make_local(_thread,obj); }
 195 #endif
 196 
 197   jclass to_jclass(Klass* klass) { return (klass == NULL ? NULL : (jclass)to_jobject(klass->java_mirror())); }
 198 
 199   jmethodID to_jmethodID(const methodHandle& method) { return method->jmethod_id(); }
 200 
 201   JNIEnv* jni_env() { return _jni_env; }
 202 };
 203 
 204 class JvmtiThreadEventMark : public JvmtiEventMark {
 205 private:
 206   jthread _jt;
 207 
 208 public:
 209   JvmtiThreadEventMark(JavaThread *thread) :
 210     JvmtiEventMark(thread) {
 211     _jt = (jthread)(to_jobject(thread->threadObj()));
 212   };
 213  jthread jni_thread() { return _jt; }
 214 };
 215 
 216 class JvmtiClassEventMark : public JvmtiThreadEventMark {
 217 private:
 218   jclass _jc;
 219 
 220 public:
 221   JvmtiClassEventMark(JavaThread *thread, Klass* klass) :
 222     JvmtiThreadEventMark(thread) {
 223     _jc = to_jclass(klass);
 224   };
 225   jclass jni_class() { return _jc; }
 226 };
 227 
 228 class JvmtiMethodEventMark : public JvmtiThreadEventMark {
 229 private:
 230   jmethodID _mid;
 231 
 232 public:
 233   JvmtiMethodEventMark(JavaThread *thread, const methodHandle& method) :
 234     JvmtiThreadEventMark(thread),
 235     _mid(to_jmethodID(method)) {};
 236   jmethodID jni_methodID() { return _mid; }
 237 };
 238 
 239 class JvmtiLocationEventMark : public JvmtiMethodEventMark {
 240 private:
 241   jlocation _loc;
 242 
 243 public:
 244   JvmtiLocationEventMark(JavaThread *thread, const methodHandle& method, address location) :
 245     JvmtiMethodEventMark(thread, method),
 246     _loc(location - method->code_base()) {};
 247   jlocation location() { return _loc; }
 248 };
 249 
 250 class JvmtiExceptionEventMark : public JvmtiLocationEventMark {
 251 private:
 252   jobject _exc;
 253 
 254 public:
 255   JvmtiExceptionEventMark(JavaThread *thread, const methodHandle& method, address location, Handle exception) :
 256     JvmtiLocationEventMark(thread, method, location),
 257     _exc(to_jobject(exception())) {};
 258   jobject exception() { return _exc; }
 259 };
 260 
 261 class JvmtiClassFileLoadEventMark : public JvmtiThreadEventMark {
 262 private:
 263   const char *_class_name;
 264   jobject _jloader;
 265   jobject _protection_domain;
 266   jclass  _class_being_redefined;
 267 
 268 public:
 269   JvmtiClassFileLoadEventMark(JavaThread *thread, Symbol* name,
 270      Handle class_loader, Handle prot_domain, Klass* class_being_redefined) : JvmtiThreadEventMark(thread) {
 271       _class_name = name != NULL? name->as_utf8() : NULL;
 272       _jloader = (jobject)to_jobject(class_loader());
 273       _protection_domain = (jobject)to_jobject(prot_domain());
 274       if (class_being_redefined == NULL) {
 275         _class_being_redefined = NULL;
 276       } else {
 277         _class_being_redefined = (jclass)to_jclass(class_being_redefined);
 278       }
 279   };
 280   const char *class_name() {
 281     return _class_name;
 282   }
 283   jobject jloader() {
 284     return _jloader;
 285   }
 286   jobject protection_domain() {
 287     return _protection_domain;
 288   }
 289   jclass class_being_redefined() {
 290     return _class_being_redefined;
 291   }
 292 };
 293 
 294 //////////////////////////////////////////////////////////////////////////////
 295 
 296 int               JvmtiExport::_field_access_count                        = 0;
 297 int               JvmtiExport::_field_modification_count                  = 0;
 298 
 299 bool              JvmtiExport::_can_access_local_variables                = false;
 300 bool              JvmtiExport::_can_hotswap_or_post_breakpoint            = false;
 301 bool              JvmtiExport::_can_modify_any_class                      = false;
 302 bool              JvmtiExport::_can_walk_any_space                        = false;
 303 
 304 bool              JvmtiExport::_has_redefined_a_class                     = false;
 305 bool              JvmtiExport::_all_dependencies_are_recorded             = false;
 306 
 307 //
 308 // field access management
 309 //
 310 
 311 // interpreter generator needs the address of the counter
 312 address JvmtiExport::get_field_access_count_addr() {
 313   // We don't grab a lock because we don't want to
 314   // serialize field access between all threads. This means that a
 315   // thread on another processor can see the wrong count value and
 316   // may either miss making a needed call into post_field_access()
 317   // or will make an unneeded call into post_field_access(). We pay
 318   // this price to avoid slowing down the VM when we aren't watching
 319   // field accesses.
 320   // Other access/mutation safe by virtue of being in VM state.
 321   return (address)(&_field_access_count);
 322 }
 323 
 324 //
 325 // field modification management
 326 //
 327 
 328 // interpreter generator needs the address of the counter
 329 address JvmtiExport::get_field_modification_count_addr() {
 330   // We don't grab a lock because we don't
 331   // want to serialize field modification between all threads. This
 332   // means that a thread on another processor can see the wrong
 333   // count value and may either miss making a needed call into
 334   // post_field_modification() or will make an unneeded call into
 335   // post_field_modification(). We pay this price to avoid slowing
 336   // down the VM when we aren't watching field modifications.
 337   // Other access/mutation safe by virtue of being in VM state.
 338   return (address)(&_field_modification_count);
 339 }
 340 
 341 
 342 ///////////////////////////////////////////////////////////////
 343 // Functions needed by java.lang.instrument for starting up javaagent.
 344 ///////////////////////////////////////////////////////////////
 345 
 346 jint
 347 JvmtiExport::get_jvmti_interface(JavaVM *jvm, void **penv, jint version) {
 348   // The JVMTI_VERSION_INTERFACE_JVMTI part of the version number
 349   // has already been validated in JNI GetEnv().
 350   int major, minor, micro;
 351 
 352   // micro version doesn't matter here (yet?)
 353   decode_version_values(version, &major, &minor, &micro);
 354   switch (major) {
 355     case 1:
 356       switch (minor) {
 357         case 0:  // version 1.0.<micro> is recognized
 358         case 1:  // version 1.1.<micro> is recognized
 359         case 2:  // version 1.2.<micro> is recognized
 360           break;
 361 
 362         default:
 363           return JNI_EVERSION;  // unsupported minor version number
 364       }
 365       break;
 366     case 9:
 367       switch (minor) {
 368         case 0:  // version 9.0.<micro> is recognized
 369           break;
 370         default:
 371           return JNI_EVERSION;  // unsupported minor version number
 372       }
 373       break;
 374     default:
 375       return JNI_EVERSION;  // unsupported major version number
 376   }
 377 
 378   if (JvmtiEnv::get_phase() == JVMTI_PHASE_LIVE) {
 379     JavaThread* current_thread = JavaThread::current();
 380     // transition code: native to VM
 381     ThreadInVMfromNative __tiv(current_thread);
 382     VM_ENTRY_BASE(jvmtiEnv*, JvmtiExport::get_jvmti_interface, current_thread)
 383     debug_only(VMNativeEntryWrapper __vew;)
 384 
 385     JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version);
 386     *penv = jvmti_env->jvmti_external();  // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv*
 387     return JNI_OK;
 388 
 389   } else if (JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) {
 390     // not live, no thread to transition
 391     JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version);
 392     *penv = jvmti_env->jvmti_external();  // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv*
 393     return JNI_OK;
 394 
 395   } else {
 396     // Called at the wrong time
 397     *penv = NULL;
 398     return JNI_EDETACHED;
 399   }
 400 }
 401 
 402 void
 403 JvmtiExport::add_default_read_edges(Handle h_module, TRAPS) {
 404   if (!Universe::is_module_initialized()) {
 405     return; // extra safety
 406   }
 407   assert(!h_module.is_null(), "module should always be set");
 408 
 409   // Invoke the transformedByAgent method
 410   JavaValue result(T_VOID);
 411   JavaCalls::call_static(&result,
 412                          SystemDictionary::module_Modules_klass(),
 413                          vmSymbols::transformedByAgent_name(),
 414                          vmSymbols::transformedByAgent_signature(),
 415                          h_module,
 416                          THREAD);
 417 
 418   if (HAS_PENDING_EXCEPTION) {
 419     LogTarget(Trace, jvmti) log;
 420     LogStream log_stream(log);
 421     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 422     log_stream.cr();
 423     CLEAR_PENDING_EXCEPTION;
 424     return;
 425   }
 426 }
 427 
 428 jvmtiError
 429 JvmtiExport::add_module_reads(Handle module, Handle to_module, TRAPS) {
 430   if (!Universe::is_module_initialized()) {
 431     return JVMTI_ERROR_NONE; // extra safety
 432   }
 433   assert(!module.is_null(), "module should always be set");
 434   assert(!to_module.is_null(), "to_module should always be set");
 435 
 436   // Invoke the addReads method
 437   JavaValue result(T_VOID);
 438   JavaCalls::call_static(&result,
 439                          SystemDictionary::module_Modules_klass(),
 440                          vmSymbols::addReads_name(),
 441                          vmSymbols::addReads_signature(),
 442                          module,
 443                          to_module,
 444                          THREAD);
 445 
 446   if (HAS_PENDING_EXCEPTION) {
 447     LogTarget(Trace, jvmti) log;
 448     LogStream log_stream(log);
 449     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 450     log_stream.cr();
 451     CLEAR_PENDING_EXCEPTION;
 452     return JVMTI_ERROR_INTERNAL;
 453   }
 454   return JVMTI_ERROR_NONE;
 455 }
 456 
 457 jvmtiError
 458 JvmtiExport::add_module_exports(Handle module, Handle pkg_name, Handle to_module, TRAPS) {
 459   if (!Universe::is_module_initialized()) {
 460     return JVMTI_ERROR_NONE; // extra safety
 461   }
 462   assert(!module.is_null(), "module should always be set");
 463   assert(!to_module.is_null(), "to_module should always be set");
 464   assert(!pkg_name.is_null(), "pkg_name should always be set");
 465 
 466   // Invoke the addExports method
 467   JavaValue result(T_VOID);
 468   JavaCalls::call_static(&result,
 469                          SystemDictionary::module_Modules_klass(),
 470                          vmSymbols::addExports_name(),
 471                          vmSymbols::addExports_signature(),
 472                          module,
 473                          pkg_name,
 474                          to_module,
 475                          THREAD);
 476 
 477   if (HAS_PENDING_EXCEPTION) {
 478     Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
 479     LogTarget(Trace, jvmti) log;
 480     LogStream log_stream(log);
 481     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 482     log_stream.cr();
 483     CLEAR_PENDING_EXCEPTION;
 484     if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) {
 485       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 486     }
 487     return JVMTI_ERROR_INTERNAL;
 488   }
 489   return JVMTI_ERROR_NONE;
 490 }
 491 
 492 jvmtiError
 493 JvmtiExport::add_module_opens(Handle module, Handle pkg_name, Handle to_module, TRAPS) {
 494   if (!Universe::is_module_initialized()) {
 495     return JVMTI_ERROR_NONE; // extra safety
 496   }
 497   assert(!module.is_null(), "module should always be set");
 498   assert(!to_module.is_null(), "to_module should always be set");
 499   assert(!pkg_name.is_null(), "pkg_name should always be set");
 500 
 501   // Invoke the addOpens method
 502   JavaValue result(T_VOID);
 503   JavaCalls::call_static(&result,
 504                          SystemDictionary::module_Modules_klass(),
 505                          vmSymbols::addOpens_name(),
 506                          vmSymbols::addExports_signature(),
 507                          module,
 508                          pkg_name,
 509                          to_module,
 510                          THREAD);
 511 
 512   if (HAS_PENDING_EXCEPTION) {
 513     Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
 514     LogTarget(Trace, jvmti) log;
 515     LogStream log_stream(log);
 516     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 517     log_stream.cr();
 518     CLEAR_PENDING_EXCEPTION;
 519     if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) {
 520       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 521     }
 522     return JVMTI_ERROR_INTERNAL;
 523   }
 524   return JVMTI_ERROR_NONE;
 525 }
 526 
 527 jvmtiError
 528 JvmtiExport::add_module_uses(Handle module, Handle service, TRAPS) {
 529   if (!Universe::is_module_initialized()) {
 530     return JVMTI_ERROR_NONE; // extra safety
 531   }
 532   assert(!module.is_null(), "module should always be set");
 533   assert(!service.is_null(), "service should always be set");
 534 
 535   // Invoke the addUses method
 536   JavaValue result(T_VOID);
 537   JavaCalls::call_static(&result,
 538                          SystemDictionary::module_Modules_klass(),
 539                          vmSymbols::addUses_name(),
 540                          vmSymbols::addUses_signature(),
 541                          module,
 542                          service,
 543                          THREAD);
 544 
 545   if (HAS_PENDING_EXCEPTION) {
 546     LogTarget(Trace, jvmti) log;
 547     LogStream log_stream(log);
 548     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 549     log_stream.cr();
 550     CLEAR_PENDING_EXCEPTION;
 551     return JVMTI_ERROR_INTERNAL;
 552   }
 553   return JVMTI_ERROR_NONE;
 554 }
 555 
 556 jvmtiError
 557 JvmtiExport::add_module_provides(Handle module, Handle service, Handle impl_class, TRAPS) {
 558   if (!Universe::is_module_initialized()) {
 559     return JVMTI_ERROR_NONE; // extra safety
 560   }
 561   assert(!module.is_null(), "module should always be set");
 562   assert(!service.is_null(), "service should always be set");
 563   assert(!impl_class.is_null(), "impl_class should always be set");
 564 
 565   // Invoke the addProvides method
 566   JavaValue result(T_VOID);
 567   JavaCalls::call_static(&result,
 568                          SystemDictionary::module_Modules_klass(),
 569                          vmSymbols::addProvides_name(),
 570                          vmSymbols::addProvides_signature(),
 571                          module,
 572                          service,
 573                          impl_class,
 574                          THREAD);
 575 
 576   if (HAS_PENDING_EXCEPTION) {
 577     LogTarget(Trace, jvmti) log;
 578     LogStream log_stream(log);
 579     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);
 580     log_stream.cr();
 581     CLEAR_PENDING_EXCEPTION;
 582     return JVMTI_ERROR_INTERNAL;
 583   }
 584   return JVMTI_ERROR_NONE;
 585 }
 586 
 587 void
 588 JvmtiExport::decode_version_values(jint version, int * major, int * minor,
 589                                    int * micro) {
 590   *major = (version & JVMTI_VERSION_MASK_MAJOR) >> JVMTI_VERSION_SHIFT_MAJOR;
 591   *minor = (version & JVMTI_VERSION_MASK_MINOR) >> JVMTI_VERSION_SHIFT_MINOR;
 592   *micro = (version & JVMTI_VERSION_MASK_MICRO) >> JVMTI_VERSION_SHIFT_MICRO;
 593 }
 594 
 595 void JvmtiExport::enter_primordial_phase() {
 596   JvmtiEnvBase::set_phase(JVMTI_PHASE_PRIMORDIAL);
 597 }
 598 
 599 void JvmtiExport::enter_early_start_phase() {
 600   JvmtiManageCapabilities::recompute_always_capabilities();
 601   set_early_vmstart_recorded(true);
 602 }
 603 
 604 void JvmtiExport::enter_start_phase() {
 605   JvmtiManageCapabilities::recompute_always_capabilities();
 606   JvmtiEnvBase::set_phase(JVMTI_PHASE_START);
 607 }
 608 
 609 void JvmtiExport::enter_onload_phase() {
 610   JvmtiEnvBase::set_phase(JVMTI_PHASE_ONLOAD);
 611 }
 612 
 613 void JvmtiExport::enter_live_phase() {
 614   JvmtiEnvBase::set_phase(JVMTI_PHASE_LIVE);
 615 }
 616 
 617 //
 618 // JVMTI events that the VM posts to the debugger and also startup agent
 619 // and call the agent's premain() for java.lang.instrument.
 620 //
 621 
 622 void JvmtiExport::post_early_vm_start() {
 623   EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg Early VM start event triggered" ));
 624 
 625   // can now enable some events
 626   JvmtiEventController::vm_start();
 627 
 628   JvmtiEnvIterator it;
 629   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 630     // Only early vmstart envs post early VMStart event
 631     if (env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) {
 632       EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt Early VM start event sent" ));
 633       JavaThread *thread  = JavaThread::current();
 634       JvmtiThreadEventMark jem(thread);
 635       JvmtiJavaThreadEventTransition jet(thread);
 636       jvmtiEventVMStart callback = env->callbacks()->VMStart;
 637       if (callback != NULL) {
 638         (*callback)(env->jvmti_external(), jem.jni_env());
 639       }
 640     }
 641   }
 642 }
 643 
 644 void JvmtiExport::post_vm_start() {
 645   EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg VM start event triggered" ));
 646 
 647   // can now enable some events
 648   JvmtiEventController::vm_start();
 649 
 650   JvmtiEnvIterator it;
 651   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 652     // Early vmstart envs do not post normal VMStart event
 653     if (!env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) {
 654       EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt VM start event sent" ));
 655 
 656       JavaThread *thread  = JavaThread::current();
 657       JvmtiThreadEventMark jem(thread);
 658       JvmtiJavaThreadEventTransition jet(thread);
 659       jvmtiEventVMStart callback = env->callbacks()->VMStart;
 660       if (callback != NULL) {
 661         (*callback)(env->jvmti_external(), jem.jni_env());
 662       }
 663     }
 664   }
 665 }
 666 
 667 
 668 void JvmtiExport::post_vm_initialized() {
 669   EVT_TRIG_TRACE(JVMTI_EVENT_VM_INIT, ("Trg VM init event triggered" ));
 670 
 671   // can now enable events
 672   JvmtiEventController::vm_init();
 673 
 674   JvmtiEnvIterator it;
 675   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 676     if (env->is_enabled(JVMTI_EVENT_VM_INIT)) {
 677       EVT_TRACE(JVMTI_EVENT_VM_INIT, ("Evt VM init event sent" ));
 678 
 679       JavaThread *thread  = JavaThread::current();
 680       JvmtiThreadEventMark jem(thread);
 681       JvmtiJavaThreadEventTransition jet(thread);
 682       jvmtiEventVMInit callback = env->callbacks()->VMInit;
 683       if (callback != NULL) {
 684         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
 685       }
 686     }
 687   }
 688 }
 689 
 690 
 691 void JvmtiExport::post_vm_death() {
 692   EVT_TRIG_TRACE(JVMTI_EVENT_VM_DEATH, ("Trg VM death event triggered" ));
 693 
 694   JvmtiEnvIterator it;
 695   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 696     if (env->is_enabled(JVMTI_EVENT_VM_DEATH)) {
 697       EVT_TRACE(JVMTI_EVENT_VM_DEATH, ("Evt VM death event sent" ));
 698 
 699       JavaThread *thread  = JavaThread::current();
 700       JvmtiEventMark jem(thread);
 701       JvmtiJavaThreadEventTransition jet(thread);
 702       jvmtiEventVMDeath callback = env->callbacks()->VMDeath;
 703       if (callback != NULL) {
 704         (*callback)(env->jvmti_external(), jem.jni_env());
 705       }
 706     }
 707   }
 708 
 709   JvmtiEnvBase::set_phase(JVMTI_PHASE_DEAD);
 710   JvmtiEventController::vm_death();
 711 }
 712 
 713 char**
 714 JvmtiExport::get_all_native_method_prefixes(int* count_ptr) {
 715   // Have to grab JVMTI thread state lock to be sure environment doesn't
 716   // go away while we iterate them.  No locks during VM bring-up.
 717   if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) {
 718     return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr);
 719   } else {
 720     MutexLocker mu(JvmtiThreadState_lock);
 721     return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr);
 722   }
 723 }
 724 
 725 // Convert an external thread reference to a JavaThread found on the
 726 // specified ThreadsList. The ThreadsListHandle in the caller "protects"
 727 // the returned JavaThread *.
 728 //
 729 // If thread_oop_p is not NULL, then the caller wants to use the oop
 730 // after this call so the oop is returned. On success, *jt_pp is set
 731 // to the converted JavaThread * and JVMTI_ERROR_NONE is returned.
 732 // On error, returns various JVMTI_ERROR_* values.
 733 //
 734 jvmtiError
 735 JvmtiExport::cv_external_thread_to_JavaThread(ThreadsList * t_list,
 736                                               jthread thread,
 737                                               JavaThread ** jt_pp,
 738                                               oop * thread_oop_p) {
 739   assert(t_list != NULL, "must have a ThreadsList");
 740   assert(jt_pp != NULL, "must have a return JavaThread pointer");
 741   // thread_oop_p is optional so no assert()
 742 
 743   oop thread_oop = JNIHandles::resolve_external_guard(thread);
 744   if (thread_oop == NULL) {
 745     // NULL jthread, GC'ed jthread or a bad JNI handle.
 746     return JVMTI_ERROR_INVALID_THREAD;
 747   }
 748   // Looks like an oop at this point.
 749 
 750   if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {
 751     // The oop is not a java.lang.Thread.
 752     return JVMTI_ERROR_INVALID_THREAD;
 753   }
 754   // Looks like a java.lang.Thread oop at this point.
 755 
 756   if (thread_oop_p != NULL) {
 757     // Return the oop to the caller; the caller may still want
 758     // the oop even if this function returns an error.
 759     *thread_oop_p = thread_oop;
 760   }
 761 
 762   JavaThread * java_thread = java_lang_Thread::thread(thread_oop);
 763   if (java_thread == NULL) {
 764     // The java.lang.Thread does not contain a JavaThread * so it has
 765     // not yet run or it has died.
 766     return JVMTI_ERROR_THREAD_NOT_ALIVE;
 767   }
 768   // Looks like a live JavaThread at this point.
 769 
 770   // We do not check the EnableThreadSMRExtraValidityChecks option
 771   // for this includes() call because JVM/TI's spec is tighter.
 772   if (!t_list->includes(java_thread)) {
 773     // Not on the JavaThreads list so it is not alive.
 774     return JVMTI_ERROR_THREAD_NOT_ALIVE;
 775   }
 776 
 777   // Return a live JavaThread that is "protected" by the
 778   // ThreadsListHandle in the caller.
 779   *jt_pp = java_thread;
 780 
 781   return JVMTI_ERROR_NONE;
 782 }
 783 
 784 // Convert an oop to a JavaThread found on the specified ThreadsList.
 785 // The ThreadsListHandle in the caller "protects" the returned
 786 // JavaThread *.
 787 //
 788 // On success, *jt_pp is set to the converted JavaThread * and
 789 // JVMTI_ERROR_NONE is returned. On error, returns various
 790 // JVMTI_ERROR_* values.
 791 //
 792 jvmtiError
 793 JvmtiExport::cv_oop_to_JavaThread(ThreadsList * t_list, oop thread_oop,
 794                                   JavaThread ** jt_pp) {
 795   assert(t_list != NULL, "must have a ThreadsList");
 796   assert(thread_oop != NULL, "must have an oop");
 797   assert(jt_pp != NULL, "must have a return JavaThread pointer");
 798 
 799   if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {
 800     // The oop is not a java.lang.Thread.
 801     return JVMTI_ERROR_INVALID_THREAD;
 802   }
 803   // Looks like a java.lang.Thread oop at this point.
 804 
 805   JavaThread * java_thread = java_lang_Thread::thread(thread_oop);
 806   if (java_thread == NULL) {
 807     // The java.lang.Thread does not contain a JavaThread * so it has
 808     // not yet run or it has died.
 809     return JVMTI_ERROR_THREAD_NOT_ALIVE;
 810   }
 811   // Looks like a live JavaThread at this point.
 812 
 813   // We do not check the EnableThreadSMRExtraValidityChecks option
 814   // for this includes() call because JVM/TI's spec is tighter.
 815   if (!t_list->includes(java_thread)) {
 816     // Not on the JavaThreads list so it is not alive.
 817     return JVMTI_ERROR_THREAD_NOT_ALIVE;
 818   }
 819 
 820   // Return a live JavaThread that is "protected" by the
 821   // ThreadsListHandle in the caller.
 822   *jt_pp = java_thread;
 823 
 824   return JVMTI_ERROR_NONE;
 825 }
 826 
 827 class JvmtiClassFileLoadHookPoster : public StackObj {
 828  private:
 829   Symbol*            _h_name;
 830   Handle               _class_loader;
 831   Handle               _h_protection_domain;
 832   unsigned char **     _data_ptr;
 833   unsigned char **     _end_ptr;
 834   JavaThread *         _thread;
 835   jint                 _curr_len;
 836   unsigned char *      _curr_data;
 837   JvmtiEnv *           _curr_env;
 838   JvmtiCachedClassFileData ** _cached_class_file_ptr;
 839   JvmtiThreadState *   _state;
 840   Klass*               _class_being_redefined;
 841   JvmtiClassLoadKind   _load_kind;
 842   bool                 _has_been_modified;
 843 
 844  public:
 845   inline JvmtiClassFileLoadHookPoster(Symbol* h_name, Handle class_loader,
 846                                       Handle h_protection_domain,
 847                                       unsigned char **data_ptr, unsigned char **end_ptr,
 848                                       JvmtiCachedClassFileData **cache_ptr) {
 849     _h_name = h_name;
 850     _class_loader = class_loader;
 851     _h_protection_domain = h_protection_domain;
 852     _data_ptr = data_ptr;
 853     _end_ptr = end_ptr;
 854     _thread = JavaThread::current();
 855     _curr_len = *end_ptr - *data_ptr;
 856     _curr_data = *data_ptr;
 857     _curr_env = NULL;
 858     _cached_class_file_ptr = cache_ptr;
 859     _has_been_modified = false;
 860 
 861     _state = _thread->jvmti_thread_state();
 862     if (_state != NULL) {
 863       _class_being_redefined = _state->get_class_being_redefined();
 864       _load_kind = _state->get_class_load_kind();
 865       Klass* klass = (_class_being_redefined == NULL) ? NULL : _class_being_redefined;
 866       if (_load_kind != jvmti_class_load_kind_load && klass != NULL) {
 867         ModuleEntry* module_entry = InstanceKlass::cast(klass)->module();
 868         assert(module_entry != NULL, "module_entry should always be set");
 869         if (module_entry->is_named() &&
 870             module_entry->module() != NULL &&
 871             !module_entry->has_default_read_edges()) {
 872           if (!module_entry->set_has_default_read_edges()) {
 873             // We won a potential race.
 874             // Add read edges to the unnamed modules of the bootstrap and app class loaders
 875             Handle class_module(_thread, module_entry->module()); // Obtain j.l.r.Module
 876             JvmtiExport::add_default_read_edges(class_module, _thread);
 877           }
 878         }
 879       }
 880       // Clear class_being_redefined flag here. The action
 881       // from agent handler could generate a new class file load
 882       // hook event and if it is not cleared the new event generated
 883       // from regular class file load could have this stale redefined
 884       // class handle info.
 885       _state->clear_class_being_redefined();
 886     } else {
 887       // redefine and retransform will always set the thread state
 888       _class_being_redefined = NULL;
 889       _load_kind = jvmti_class_load_kind_load;
 890     }
 891   }
 892 
 893   void post() {
 894     post_all_envs();
 895     copy_modified_data();
 896   }
 897 
 898   bool has_been_modified() { return _has_been_modified; }
 899 
 900  private:
 901   void post_all_envs() {
 902     if (_load_kind != jvmti_class_load_kind_retransform) {
 903       // for class load and redefine,
 904       // call the non-retransformable agents
 905       JvmtiEnvIterator it;
 906       for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 907         if (!env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) {
 908           // non-retransformable agents cannot retransform back,
 909           // so no need to cache the original class file bytes
 910           post_to_env(env, false);
 911         }
 912       }
 913     }
 914     JvmtiEnvIterator it;
 915     for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 916       // retransformable agents get all events
 917       if (env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) {
 918         // retransformable agents need to cache the original class file
 919         // bytes if changes are made via the ClassFileLoadHook
 920         post_to_env(env, true);
 921       }
 922     }
 923   }
 924 
 925   void post_to_env(JvmtiEnv* env, bool caching_needed) {
 926     if (env->phase() == JVMTI_PHASE_PRIMORDIAL && !env->early_class_hook_env()) {
 927       return;
 928     }
 929     unsigned char *new_data = NULL;
 930     jint new_len = 0;
 931     JvmtiClassFileLoadEventMark jem(_thread, _h_name, _class_loader,
 932                                     _h_protection_domain,
 933                                     _class_being_redefined);
 934     JvmtiJavaThreadEventTransition jet(_thread);
 935     jvmtiEventClassFileLoadHook callback = env->callbacks()->ClassFileLoadHook;
 936     if (callback != NULL) {
 937       (*callback)(env->jvmti_external(), jem.jni_env(),
 938                   jem.class_being_redefined(),
 939                   jem.jloader(), jem.class_name(),
 940                   jem.protection_domain(),
 941                   _curr_len, _curr_data,
 942                   &new_len, &new_data);
 943     }
 944     if (new_data != NULL) {
 945       // this agent has modified class data.
 946       _has_been_modified = true;
 947       if (caching_needed && *_cached_class_file_ptr == NULL) {
 948         // data has been changed by the new retransformable agent
 949         // and it hasn't already been cached, cache it
 950         JvmtiCachedClassFileData *p;
 951         p = (JvmtiCachedClassFileData *)os::malloc(
 952           offset_of(JvmtiCachedClassFileData, data) + _curr_len, mtInternal);
 953         if (p == NULL) {
 954           vm_exit_out_of_memory(offset_of(JvmtiCachedClassFileData, data) + _curr_len,
 955             OOM_MALLOC_ERROR,
 956             "unable to allocate cached copy of original class bytes");
 957         }
 958         p->length = _curr_len;
 959         memcpy(p->data, _curr_data, _curr_len);
 960         *_cached_class_file_ptr = p;
 961       }
 962 
 963       if (_curr_data != *_data_ptr) {
 964         // curr_data is previous agent modified class data.
 965         // And this has been changed by the new agent so
 966         // we can delete it now.
 967         _curr_env->Deallocate(_curr_data);
 968       }
 969 
 970       // Class file data has changed by the current agent.
 971       _curr_data = new_data;
 972       _curr_len = new_len;
 973       // Save the current agent env we need this to deallocate the
 974       // memory allocated by this agent.
 975       _curr_env = env;
 976     }
 977   }
 978 
 979   void copy_modified_data() {
 980     // if one of the agent has modified class file data.
 981     // Copy modified class data to new resources array.
 982     if (_curr_data != *_data_ptr) {
 983       *_data_ptr = NEW_RESOURCE_ARRAY(u1, _curr_len);
 984       memcpy(*_data_ptr, _curr_data, _curr_len);
 985       *_end_ptr = *_data_ptr + _curr_len;
 986       _curr_env->Deallocate(_curr_data);
 987     }
 988   }
 989 };
 990 
 991 bool JvmtiExport::_should_post_class_file_load_hook = false;
 992 
 993 // this entry is for class file load hook on class load, redefine and retransform
 994 bool JvmtiExport::post_class_file_load_hook(Symbol* h_name,
 995                                             Handle class_loader,
 996                                             Handle h_protection_domain,
 997                                             unsigned char **data_ptr,
 998                                             unsigned char **end_ptr,
 999                                             JvmtiCachedClassFileData **cache_ptr) {
1000   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1001     return false;
1002   }
1003 
1004   JvmtiClassFileLoadHookPoster poster(h_name, class_loader,
1005                                       h_protection_domain,
1006                                       data_ptr, end_ptr,
1007                                       cache_ptr);
1008   poster.post();
1009   return poster.has_been_modified();
1010 }
1011 
1012 void JvmtiExport::report_unsupported(bool on) {
1013   // If any JVMTI service is turned on, we need to exit before native code
1014   // tries to access nonexistant services.
1015   if (on) {
1016     vm_exit_during_initialization("Java Kernel does not support JVMTI.");
1017   }
1018 }
1019 
1020 
1021 static inline Klass* oop_to_klass(oop obj) {
1022   Klass* k = obj->klass();
1023 
1024   // if the object is a java.lang.Class then return the java mirror
1025   if (k == SystemDictionary::Class_klass()) {
1026     if (!java_lang_Class::is_primitive(obj)) {
1027       k = java_lang_Class::as_Klass(obj);
1028       assert(k != NULL, "class for non-primitive mirror must exist");
1029     }
1030   }
1031   return k;
1032 }
1033 
1034 class JvmtiVMObjectAllocEventMark : public JvmtiClassEventMark  {
1035  private:
1036    jobject _jobj;
1037    jlong    _size;
1038  public:
1039    JvmtiVMObjectAllocEventMark(JavaThread *thread, oop obj) : JvmtiClassEventMark(thread, oop_to_klass(obj)) {
1040      _jobj = (jobject)to_jobject(obj);
1041      _size = obj->size() * wordSize;
1042    };
1043    jobject jni_jobject() { return _jobj; }
1044    jlong size() { return _size; }
1045 };
1046 
1047 class JvmtiCompiledMethodLoadEventMark : public JvmtiMethodEventMark {
1048  private:
1049   jint _code_size;
1050   const void *_code_data;
1051   jint _map_length;
1052   jvmtiAddrLocationMap *_map;
1053   const void *_compile_info;
1054  public:
1055   JvmtiCompiledMethodLoadEventMark(JavaThread *thread, nmethod *nm, void* compile_info_ptr = NULL)
1056           : JvmtiMethodEventMark(thread,methodHandle(thread, nm->method())) {
1057     _code_data = nm->insts_begin();
1058     _code_size = nm->insts_size();
1059     _compile_info = compile_info_ptr; // Set void pointer of compiledMethodLoad Event. Default value is NULL.
1060     JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nm, &_map, &_map_length);
1061   }
1062   ~JvmtiCompiledMethodLoadEventMark() {
1063      FREE_C_HEAP_ARRAY(jvmtiAddrLocationMap, _map);
1064   }
1065 
1066   jint code_size() { return _code_size; }
1067   const void *code_data() { return _code_data; }
1068   jint map_length() { return _map_length; }
1069   const jvmtiAddrLocationMap* map() { return _map; }
1070   const void *compile_info() { return _compile_info; }
1071 };
1072 
1073 
1074 
1075 class JvmtiMonitorEventMark : public JvmtiThreadEventMark {
1076 private:
1077   jobject _jobj;
1078 public:
1079   JvmtiMonitorEventMark(JavaThread *thread, oop object)
1080           : JvmtiThreadEventMark(thread){
1081      _jobj = to_jobject(object);
1082   }
1083   jobject jni_object() { return _jobj; }
1084 };
1085 
1086 ///////////////////////////////////////////////////////////////
1087 //
1088 // pending CompiledMethodUnload support
1089 //
1090 
1091 void JvmtiExport::post_compiled_method_unload(
1092        jmethodID method, const void *code_begin) {
1093   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1094     return;
1095   }
1096   JavaThread* thread = JavaThread::current();
1097   EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD,
1098                  ("[%s] method compile unload event triggered",
1099                   JvmtiTrace::safe_get_thread_name(thread)));
1100 
1101   // post the event for each environment that has this event enabled.
1102   JvmtiEnvIterator it;
1103   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
1104     if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_UNLOAD)) {
1105       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1106         continue;
1107       }
1108       EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD,
1109                 ("[%s] class compile method unload event sent jmethodID " PTR_FORMAT,
1110                  JvmtiTrace::safe_get_thread_name(thread), p2i(method)));
1111 
1112       ResourceMark rm(thread);
1113 
1114       JvmtiEventMark jem(thread);
1115       JvmtiJavaThreadEventTransition jet(thread);
1116       jvmtiEventCompiledMethodUnload callback = env->callbacks()->CompiledMethodUnload;
1117       if (callback != NULL) {
1118         (*callback)(env->jvmti_external(), method, code_begin);
1119       }
1120     }
1121   }
1122 }
1123 
1124 ///////////////////////////////////////////////////////////////
1125 //
1126 // JvmtiExport
1127 //
1128 
1129 void JvmtiExport::post_raw_breakpoint(JavaThread *thread, Method* method, address location) {
1130   HandleMark hm(thread);
1131   methodHandle mh(thread, method);
1132 
1133   JvmtiThreadState *state = thread->jvmti_thread_state();
1134   if (state == NULL) {
1135     return;
1136   }
1137   EVT_TRIG_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Trg Breakpoint triggered",
1138                       JvmtiTrace::safe_get_thread_name(thread)));
1139   JvmtiEnvThreadStateIterator it(state);
1140   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1141     ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_BREAKPOINT);
1142     if (!ets->breakpoint_posted() && ets->is_enabled(JVMTI_EVENT_BREAKPOINT)) {
1143       ThreadState old_os_state = thread->osthread()->get_state();
1144       thread->osthread()->set_state(BREAKPOINTED);
1145       EVT_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Evt Breakpoint sent %s.%s @ " INTX_FORMAT,
1146                      JvmtiTrace::safe_get_thread_name(thread),
1147                      (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1148                      (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1149                      location - mh()->code_base() ));
1150 
1151       JvmtiEnv *env = ets->get_env();
1152       JvmtiLocationEventMark jem(thread, mh, location);
1153       JvmtiJavaThreadEventTransition jet(thread);
1154       jvmtiEventBreakpoint callback = env->callbacks()->Breakpoint;
1155       if (callback != NULL) {
1156         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1157                     jem.jni_methodID(), jem.location());
1158       }
1159 
1160       ets->set_breakpoint_posted();
1161       thread->osthread()->set_state(old_os_state);
1162     }
1163   }
1164 }
1165 
1166 //////////////////////////////////////////////////////////////////////////////
1167 
1168 bool              JvmtiExport::_can_get_source_debug_extension            = false;
1169 bool              JvmtiExport::_can_maintain_original_method_order        = false;
1170 bool              JvmtiExport::_can_post_interpreter_events               = false;
1171 bool              JvmtiExport::_can_post_on_exceptions                    = false;
1172 bool              JvmtiExport::_can_post_breakpoint                       = false;
1173 bool              JvmtiExport::_can_post_field_access                     = false;
1174 bool              JvmtiExport::_can_post_field_modification               = false;
1175 bool              JvmtiExport::_can_post_method_entry                     = false;
1176 bool              JvmtiExport::_can_post_method_exit                      = false;
1177 bool              JvmtiExport::_can_pop_frame                             = false;
1178 bool              JvmtiExport::_can_force_early_return                    = false;
1179 
1180 bool              JvmtiExport::_early_vmstart_recorded                    = false;
1181 
1182 bool              JvmtiExport::_should_post_single_step                   = false;
1183 bool              JvmtiExport::_should_post_field_access                  = false;
1184 bool              JvmtiExport::_should_post_field_modification            = false;
1185 bool              JvmtiExport::_should_post_class_load                    = false;
1186 bool              JvmtiExport::_should_post_class_prepare                 = false;
1187 bool              JvmtiExport::_should_post_class_unload                  = false;
1188 bool              JvmtiExport::_should_post_thread_life                   = false;
1189 bool              JvmtiExport::_should_clean_up_heap_objects              = false;
1190 bool              JvmtiExport::_should_post_native_method_bind            = false;
1191 bool              JvmtiExport::_should_post_dynamic_code_generated        = false;
1192 bool              JvmtiExport::_should_post_data_dump                     = false;
1193 bool              JvmtiExport::_should_post_compiled_method_load          = false;
1194 bool              JvmtiExport::_should_post_compiled_method_unload        = false;
1195 bool              JvmtiExport::_should_post_monitor_contended_enter       = false;
1196 bool              JvmtiExport::_should_post_monitor_contended_entered     = false;
1197 bool              JvmtiExport::_should_post_monitor_wait                  = false;
1198 bool              JvmtiExport::_should_post_monitor_waited                = false;
1199 bool              JvmtiExport::_should_post_garbage_collection_start      = false;
1200 bool              JvmtiExport::_should_post_garbage_collection_finish     = false;
1201 bool              JvmtiExport::_should_post_object_free                   = false;
1202 bool              JvmtiExport::_should_post_resource_exhausted            = false;
1203 bool              JvmtiExport::_should_post_vm_object_alloc               = false;
1204 bool              JvmtiExport::_should_post_on_exceptions                 = false;
1205 
1206 ////////////////////////////////////////////////////////////////////////////////////////////////
1207 
1208 
1209 //
1210 // JVMTI single step management
1211 //
1212 void JvmtiExport::at_single_stepping_point(JavaThread *thread, Method* method, address location) {
1213   assert(JvmtiExport::should_post_single_step(), "must be single stepping");
1214 
1215   HandleMark hm(thread);
1216   methodHandle mh(thread, method);
1217 
1218   // update information about current location and post a step event
1219   JvmtiThreadState *state = thread->jvmti_thread_state();
1220   if (state == NULL) {
1221     return;
1222   }
1223   EVT_TRIG_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Trg Single Step triggered",
1224                       JvmtiTrace::safe_get_thread_name(thread)));
1225   if (!state->hide_single_stepping()) {
1226     if (state->is_pending_step_for_popframe()) {
1227       state->process_pending_step_for_popframe();
1228     }
1229     if (state->is_pending_step_for_earlyret()) {
1230       state->process_pending_step_for_earlyret();
1231     }
1232     JvmtiExport::post_single_step(thread, mh(), location);
1233   }
1234 }
1235 
1236 
1237 void JvmtiExport::expose_single_stepping(JavaThread *thread) {
1238   JvmtiThreadState *state = thread->jvmti_thread_state();
1239   if (state != NULL) {
1240     state->clear_hide_single_stepping();
1241   }
1242 }
1243 
1244 
1245 bool JvmtiExport::hide_single_stepping(JavaThread *thread) {
1246   JvmtiThreadState *state = thread->jvmti_thread_state();
1247   if (state != NULL && state->is_enabled(JVMTI_EVENT_SINGLE_STEP)) {
1248     state->set_hide_single_stepping();
1249     return true;
1250   } else {
1251     return false;
1252   }
1253 }
1254 
1255 void JvmtiExport::post_class_load(JavaThread *thread, Klass* klass) {
1256   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1257     return;
1258   }
1259   HandleMark hm(thread);
1260 
1261   EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Trg Class Load triggered",
1262                       JvmtiTrace::safe_get_thread_name(thread)));
1263   JvmtiThreadState* state = thread->jvmti_thread_state();
1264   if (state == NULL) {
1265     return;
1266   }
1267   JvmtiEnvThreadStateIterator it(state);
1268   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1269     if (ets->is_enabled(JVMTI_EVENT_CLASS_LOAD)) {
1270       JvmtiEnv *env = ets->get_env();
1271       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1272         continue;
1273       }
1274       EVT_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Evt Class Load sent %s",
1275                                          JvmtiTrace::safe_get_thread_name(thread),
1276                                          klass==NULL? "NULL" : klass->external_name() ));
1277       JvmtiClassEventMark jem(thread, klass);
1278       JvmtiJavaThreadEventTransition jet(thread);
1279       jvmtiEventClassLoad callback = env->callbacks()->ClassLoad;
1280       if (callback != NULL) {
1281         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class());
1282       }
1283     }
1284   }
1285 }
1286 
1287 
1288 void JvmtiExport::post_class_prepare(JavaThread *thread, Klass* klass) {
1289   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1290     return;
1291   }
1292   HandleMark hm(thread);
1293 
1294   EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Trg Class Prepare triggered",
1295                       JvmtiTrace::safe_get_thread_name(thread)));
1296   JvmtiThreadState* state = thread->jvmti_thread_state();
1297   if (state == NULL) {
1298     return;
1299   }
1300   JvmtiEnvThreadStateIterator it(state);
1301   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1302     if (ets->is_enabled(JVMTI_EVENT_CLASS_PREPARE)) {
1303       JvmtiEnv *env = ets->get_env();
1304       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1305         continue;
1306       }
1307       EVT_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Evt Class Prepare sent %s",
1308                                             JvmtiTrace::safe_get_thread_name(thread),
1309                                             klass==NULL? "NULL" : klass->external_name() ));
1310       JvmtiClassEventMark jem(thread, klass);
1311       JvmtiJavaThreadEventTransition jet(thread);
1312       jvmtiEventClassPrepare callback = env->callbacks()->ClassPrepare;
1313       if (callback != NULL) {
1314         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class());
1315       }
1316     }
1317   }
1318 }
1319 
1320 void JvmtiExport::post_class_unload(Klass* klass) {
1321   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1322     return;
1323   }
1324   Thread *thread = Thread::current();
1325   HandleMark hm(thread);
1326 
1327   EVT_TRIG_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Trg Class Unload triggered" ));
1328   if (JvmtiEventController::is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) {
1329     assert(thread->is_VM_thread(), "wrong thread");
1330 
1331     // get JavaThread for whom we are proxy
1332     Thread *calling_thread = ((VMThread *)thread)->vm_operation()->calling_thread();
1333     if (!calling_thread->is_Java_thread()) {
1334       // cannot post an event to a non-JavaThread
1335       return;
1336     }
1337     JavaThread *real_thread = (JavaThread *)calling_thread;
1338 
1339     JvmtiEnvIterator it;
1340     for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
1341       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1342         continue;
1343       }
1344       if (env->is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) {
1345         EVT_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Evt Class Unload sent %s",
1346                   klass==NULL? "NULL" : klass->external_name() ));
1347 
1348         // do everything manually, since this is a proxy - needs special care
1349         JNIEnv* jni_env = real_thread->jni_environment();
1350         jthread jt = (jthread)JNIHandles::make_local(real_thread, real_thread->threadObj());
1351         jclass jk = (jclass)JNIHandles::make_local(real_thread, klass->java_mirror());
1352 
1353         // Before we call the JVMTI agent, we have to set the state in the
1354         // thread for which we are proxying.
1355         JavaThreadState prev_state = real_thread->thread_state();
1356         assert(((Thread *)real_thread)->is_ConcurrentGC_thread() ||
1357                (real_thread->is_Java_thread() && prev_state == _thread_blocked),
1358                "should be ConcurrentGCThread or JavaThread at safepoint");
1359         real_thread->set_thread_state(_thread_in_native);
1360 
1361         jvmtiExtensionEvent callback = env->ext_callbacks()->ClassUnload;
1362         if (callback != NULL) {
1363           (*callback)(env->jvmti_external(), jni_env, jt, jk);
1364         }
1365 
1366         assert(real_thread->thread_state() == _thread_in_native,
1367                "JavaThread should be in native");
1368         real_thread->set_thread_state(prev_state);
1369 
1370         JNIHandles::destroy_local(jk);
1371         JNIHandles::destroy_local(jt);
1372       }
1373     }
1374   }
1375 }
1376 
1377 
1378 void JvmtiExport::post_thread_start(JavaThread *thread) {
1379   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1380     return;
1381   }
1382   assert(thread->thread_state() == _thread_in_vm, "must be in vm state");
1383 
1384   EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Trg Thread Start event triggered",
1385                       JvmtiTrace::safe_get_thread_name(thread)));
1386 
1387   // do JVMTI thread initialization (if needed)
1388   JvmtiEventController::thread_started(thread);
1389 
1390   // Do not post thread start event for hidden java thread.
1391   if (JvmtiEventController::is_enabled(JVMTI_EVENT_THREAD_START) &&
1392       !thread->is_hidden_from_external_view()) {
1393     JvmtiEnvIterator it;
1394     for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
1395       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1396         continue;
1397       }
1398       if (env->is_enabled(JVMTI_EVENT_THREAD_START)) {
1399         EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent",
1400                      JvmtiTrace::safe_get_thread_name(thread) ));
1401 
1402         JvmtiThreadEventMark jem(thread);
1403         JvmtiJavaThreadEventTransition jet(thread);
1404         jvmtiEventThreadStart callback = env->callbacks()->ThreadStart;
1405         if (callback != NULL) {
1406           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
1407         }
1408       }
1409     }
1410   }
1411 }
1412 
1413 
1414 void JvmtiExport::post_thread_end(JavaThread *thread) {
1415   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
1416     return;
1417   }
1418   EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Trg Thread End event triggered",
1419                       JvmtiTrace::safe_get_thread_name(thread)));
1420 
1421   JvmtiThreadState *state = thread->jvmti_thread_state();
1422   if (state == NULL) {
1423     return;
1424   }
1425 
1426   // Do not post thread end event for hidden java thread.
1427   if (state->is_enabled(JVMTI_EVENT_THREAD_END) &&
1428       !thread->is_hidden_from_external_view()) {
1429 
1430     JvmtiEnvThreadStateIterator it(state);
1431     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1432       if (ets->is_enabled(JVMTI_EVENT_THREAD_END)) {
1433         JvmtiEnv *env = ets->get_env();
1434         if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
1435           continue;
1436         }
1437         EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent",
1438                      JvmtiTrace::safe_get_thread_name(thread) ));
1439 
1440         JvmtiThreadEventMark jem(thread);
1441         JvmtiJavaThreadEventTransition jet(thread);
1442         jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd;
1443         if (callback != NULL) {
1444           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
1445         }
1446       }
1447     }
1448   }
1449 }
1450 
1451 void JvmtiExport::post_object_free(JvmtiEnv* env, jlong tag) {
1452   assert(SafepointSynchronize::is_at_safepoint(), "must be executed at safepoint");
1453   assert(env->is_enabled(JVMTI_EVENT_OBJECT_FREE), "checking");
1454 
1455   EVT_TRIG_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Trg Object Free triggered" ));
1456   EVT_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Evt Object Free sent"));
1457 
1458   jvmtiEventObjectFree callback = env->callbacks()->ObjectFree;
1459   if (callback != NULL) {
1460     (*callback)(env->jvmti_external(), tag);
1461   }
1462 }
1463 
1464 void JvmtiExport::post_resource_exhausted(jint resource_exhausted_flags, const char* description) {
1465   EVT_TRIG_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Trg resource exhausted event triggered" ));
1466 
1467   JvmtiEnvIterator it;
1468   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
1469     if (env->is_enabled(JVMTI_EVENT_RESOURCE_EXHAUSTED)) {
1470       EVT_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Evt resource exhausted event sent" ));
1471 
1472       JavaThread *thread  = JavaThread::current();
1473       JvmtiThreadEventMark jem(thread);
1474       JvmtiJavaThreadEventTransition jet(thread);
1475       jvmtiEventResourceExhausted callback = env->callbacks()->ResourceExhausted;
1476       if (callback != NULL) {
1477         (*callback)(env->jvmti_external(), jem.jni_env(),
1478                     resource_exhausted_flags, NULL, description);
1479       }
1480     }
1481   }
1482 }
1483 
1484 void JvmtiExport::post_method_entry(JavaThread *thread, Method* method, frame current_frame) {
1485   HandleMark hm(thread);
1486   methodHandle mh(thread, method);
1487 
1488   EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Trg Method Entry triggered %s.%s",
1489                      JvmtiTrace::safe_get_thread_name(thread),
1490                      (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1491                      (mh() == NULL) ? "NULL" : mh()->name()->as_C_string() ));
1492 
1493   JvmtiThreadState* state = thread->jvmti_thread_state();
1494   if (state == NULL || !state->is_interp_only_mode()) {
1495     // for any thread that actually wants method entry, interp_only_mode is set
1496     return;
1497   }
1498 
1499   state->incr_cur_stack_depth();
1500 
1501   if (state->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) {
1502     JvmtiEnvThreadStateIterator it(state);
1503     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1504       if (ets->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) {
1505         EVT_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Evt Method Entry sent %s.%s",
1506                                              JvmtiTrace::safe_get_thread_name(thread),
1507                                              (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1508                                              (mh() == NULL) ? "NULL" : mh()->name()->as_C_string() ));
1509 
1510         JvmtiEnv *env = ets->get_env();
1511         JvmtiMethodEventMark jem(thread, mh);
1512         JvmtiJavaThreadEventTransition jet(thread);
1513         jvmtiEventMethodEntry callback = env->callbacks()->MethodEntry;
1514         if (callback != NULL) {
1515           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_methodID());
1516         }
1517       }
1518     }
1519   }
1520 }
1521 
1522 void JvmtiExport::post_method_exit(JavaThread *thread, Method* method, frame current_frame) {
1523   HandleMark hm(thread);
1524   methodHandle mh(thread, method);
1525 
1526   EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Trg Method Exit triggered %s.%s",
1527                      JvmtiTrace::safe_get_thread_name(thread),
1528                      (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1529                      (mh() == NULL) ? "NULL" : mh()->name()->as_C_string() ));
1530 
1531   JvmtiThreadState *state = thread->jvmti_thread_state();
1532   if (state == NULL || !state->is_interp_only_mode()) {
1533     // for any thread that actually wants method exit, interp_only_mode is set
1534     return;
1535   }
1536 
1537   // return a flag when a method terminates by throwing an exception
1538   // i.e. if an exception is thrown and it's not caught by the current method
1539   bool exception_exit = state->is_exception_detected() && !state->is_exception_caught();
1540 
1541 
1542   if (state->is_enabled(JVMTI_EVENT_METHOD_EXIT)) {
1543     Handle result;
1544     jvalue value;
1545     value.j = 0L;
1546 
1547     // if the method hasn't been popped because of an exception then we populate
1548     // the return_value parameter for the callback. At this point we only have
1549     // the address of a "raw result" and we just call into the interpreter to
1550     // convert this into a jvalue.
1551     if (!exception_exit) {
1552       oop oop_result;
1553       BasicType type = current_frame.interpreter_frame_result(&oop_result, &value);
1554       if (type == T_OBJECT || type == T_ARRAY) {
1555         result = Handle(thread, oop_result);
1556       }
1557     }
1558 
1559     JvmtiEnvThreadStateIterator it(state);
1560     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1561       if (ets->is_enabled(JVMTI_EVENT_METHOD_EXIT)) {
1562         EVT_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Evt Method Exit sent %s.%s",
1563                                             JvmtiTrace::safe_get_thread_name(thread),
1564                                             (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1565                                             (mh() == NULL) ? "NULL" : mh()->name()->as_C_string() ));
1566 
1567         JvmtiEnv *env = ets->get_env();
1568         JvmtiMethodEventMark jem(thread, mh);
1569         if (result.not_null()) {
1570           value.l = JNIHandles::make_local(thread, result());
1571         }
1572         JvmtiJavaThreadEventTransition jet(thread);
1573         jvmtiEventMethodExit callback = env->callbacks()->MethodExit;
1574         if (callback != NULL) {
1575           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1576                       jem.jni_methodID(), exception_exit,  value);
1577         }
1578       }
1579     }
1580   }
1581 
1582   if (state->is_enabled(JVMTI_EVENT_FRAME_POP)) {
1583     JvmtiEnvThreadStateIterator it(state);
1584     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1585       int cur_frame_number = state->cur_stack_depth();
1586 
1587       if (ets->is_frame_pop(cur_frame_number)) {
1588         // we have a NotifyFramePop entry for this frame.
1589         // now check that this env/thread wants this event
1590         if (ets->is_enabled(JVMTI_EVENT_FRAME_POP)) {
1591           EVT_TRACE(JVMTI_EVENT_FRAME_POP, ("[%s] Evt Frame Pop sent %s.%s",
1592                                             JvmtiTrace::safe_get_thread_name(thread),
1593                                             (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1594                                             (mh() == NULL) ? "NULL" : mh()->name()->as_C_string() ));
1595 
1596           // we also need to issue a frame pop event for this frame
1597           JvmtiEnv *env = ets->get_env();
1598           JvmtiMethodEventMark jem(thread, mh);
1599           JvmtiJavaThreadEventTransition jet(thread);
1600           jvmtiEventFramePop callback = env->callbacks()->FramePop;
1601           if (callback != NULL) {
1602             (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1603                         jem.jni_methodID(), exception_exit);
1604           }
1605         }
1606         // remove the frame's entry
1607         ets->clear_frame_pop(cur_frame_number);
1608       }
1609     }
1610   }
1611 
1612   state->decr_cur_stack_depth();
1613 }
1614 
1615 
1616 // Todo: inline this for optimization
1617 void JvmtiExport::post_single_step(JavaThread *thread, Method* method, address location) {
1618   HandleMark hm(thread);
1619   methodHandle mh(thread, method);
1620 
1621   JvmtiThreadState *state = thread->jvmti_thread_state();
1622   if (state == NULL) {
1623     return;
1624   }
1625   JvmtiEnvThreadStateIterator it(state);
1626   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1627     ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_SINGLE_STEP);
1628     if (!ets->single_stepping_posted() && ets->is_enabled(JVMTI_EVENT_SINGLE_STEP)) {
1629       EVT_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Evt Single Step sent %s.%s @ " INTX_FORMAT,
1630                     JvmtiTrace::safe_get_thread_name(thread),
1631                     (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1632                     (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1633                     location - mh()->code_base() ));
1634 
1635       JvmtiEnv *env = ets->get_env();
1636       JvmtiLocationEventMark jem(thread, mh, location);
1637       JvmtiJavaThreadEventTransition jet(thread);
1638       jvmtiEventSingleStep callback = env->callbacks()->SingleStep;
1639       if (callback != NULL) {
1640         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1641                     jem.jni_methodID(), jem.location());
1642       }
1643 
1644       ets->set_single_stepping_posted();
1645     }
1646   }
1647 }
1648 
1649 void JvmtiExport::post_exception_throw(JavaThread *thread, Method* method, address location, oop exception) {
1650   HandleMark hm(thread);
1651   methodHandle mh(thread, method);
1652   Handle exception_handle(thread, exception);
1653 
1654   JvmtiThreadState *state = thread->jvmti_thread_state();
1655   if (state == NULL) {
1656     return;
1657   }
1658 
1659   EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION, ("[%s] Trg Exception thrown triggered",
1660                       JvmtiTrace::safe_get_thread_name(thread)));
1661   if (!state->is_exception_detected()) {
1662     state->set_exception_detected();
1663     JvmtiEnvThreadStateIterator it(state);
1664     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1665       if (ets->is_enabled(JVMTI_EVENT_EXCEPTION) && (exception != NULL)) {
1666 
1667         EVT_TRACE(JVMTI_EVENT_EXCEPTION,
1668                      ("[%s] Evt Exception thrown sent %s.%s @ " INTX_FORMAT,
1669                       JvmtiTrace::safe_get_thread_name(thread),
1670                       (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1671                       (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1672                       location - mh()->code_base() ));
1673 
1674         JvmtiEnv *env = ets->get_env();
1675         JvmtiExceptionEventMark jem(thread, mh, location, exception_handle);
1676 
1677         // It's okay to clear these exceptions here because we duplicate
1678         // this lookup in InterpreterRuntime::exception_handler_for_exception.
1679         EXCEPTION_MARK;
1680 
1681         bool should_repeat;
1682         vframeStream st(thread);
1683         assert(!st.at_end(), "cannot be at end");
1684         Method* current_method = NULL;
1685         // A GC may occur during the Method::fast_exception_handler_bci_for()
1686         // call below if it needs to load the constraint class. Using a
1687         // methodHandle to keep the 'current_method' from being deallocated
1688         // if GC happens.
1689         methodHandle current_mh = methodHandle(thread, current_method);
1690         int current_bci = -1;
1691         do {
1692           current_method = st.method();
1693           current_mh = methodHandle(thread, current_method);
1694           current_bci = st.bci();
1695           do {
1696             should_repeat = false;
1697             Klass* eh_klass = exception_handle()->klass();
1698             current_bci = Method::fast_exception_handler_bci_for(
1699               current_mh, eh_klass, current_bci, THREAD);
1700             if (HAS_PENDING_EXCEPTION) {
1701               exception_handle = Handle(thread, PENDING_EXCEPTION);
1702               CLEAR_PENDING_EXCEPTION;
1703               should_repeat = true;
1704             }
1705           } while (should_repeat && (current_bci != -1));
1706           st.next();
1707         } while ((current_bci < 0) && (!st.at_end()));
1708 
1709         jmethodID catch_jmethodID;
1710         if (current_bci < 0) {
1711           catch_jmethodID = 0;
1712           current_bci = 0;
1713         } else {
1714           catch_jmethodID = jem.to_jmethodID(current_mh);
1715         }
1716 
1717         JvmtiJavaThreadEventTransition jet(thread);
1718         jvmtiEventException callback = env->callbacks()->Exception;
1719         if (callback != NULL) {
1720           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1721                       jem.jni_methodID(), jem.location(),
1722                       jem.exception(),
1723                       catch_jmethodID, current_bci);
1724         }
1725       }
1726     }
1727   }
1728 
1729   // frames may get popped because of this throw, be safe - invalidate cached depth
1730   state->invalidate_cur_stack_depth();
1731 }
1732 
1733 
1734 void JvmtiExport::notice_unwind_due_to_exception(JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) {
1735   HandleMark hm(thread);
1736   methodHandle mh(thread, method);
1737   Handle exception_handle(thread, exception);
1738 
1739   JvmtiThreadState *state = thread->jvmti_thread_state();
1740   if (state == NULL) {
1741     return;
1742   }
1743   EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION_CATCH,
1744                     ("[%s] Trg unwind_due_to_exception triggered %s.%s @ %s" INTX_FORMAT " - %s",
1745                      JvmtiTrace::safe_get_thread_name(thread),
1746                      (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1747                      (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1748                      location==0? "no location:" : "",
1749                      location==0? 0 : location - mh()->code_base(),
1750                      in_handler_frame? "in handler frame" : "not handler frame" ));
1751 
1752   if (state->is_exception_detected()) {
1753 
1754     state->invalidate_cur_stack_depth();
1755     if (!in_handler_frame) {
1756       // Not in exception handler.
1757       if(state->is_interp_only_mode()) {
1758         // method exit and frame pop events are posted only in interp mode.
1759         // When these events are enabled code should be in running in interp mode.
1760         JvmtiExport::post_method_exit(thread, method, thread->last_frame());
1761         // The cached cur_stack_depth might have changed from the
1762         // operations of frame pop or method exit. We are not 100% sure
1763         // the cached cur_stack_depth is still valid depth so invalidate
1764         // it.
1765         state->invalidate_cur_stack_depth();
1766       }
1767     } else {
1768       // In exception handler frame. Report exception catch.
1769       assert(location != NULL, "must be a known location");
1770       // Update cur_stack_depth - the frames above the current frame
1771       // have been unwound due to this exception:
1772       assert(!state->is_exception_caught(), "exception must not be caught yet.");
1773       state->set_exception_caught();
1774 
1775       JvmtiEnvThreadStateIterator it(state);
1776       for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1777         if (ets->is_enabled(JVMTI_EVENT_EXCEPTION_CATCH) && (exception_handle() != NULL)) {
1778           EVT_TRACE(JVMTI_EVENT_EXCEPTION_CATCH,
1779                      ("[%s] Evt ExceptionCatch sent %s.%s @ " INTX_FORMAT,
1780                       JvmtiTrace::safe_get_thread_name(thread),
1781                       (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1782                       (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1783                       location - mh()->code_base() ));
1784 
1785           JvmtiEnv *env = ets->get_env();
1786           JvmtiExceptionEventMark jem(thread, mh, location, exception_handle);
1787           JvmtiJavaThreadEventTransition jet(thread);
1788           jvmtiEventExceptionCatch callback = env->callbacks()->ExceptionCatch;
1789           if (callback != NULL) {
1790             (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1791                       jem.jni_methodID(), jem.location(),
1792                       jem.exception());
1793           }
1794         }
1795       }
1796     }
1797   }
1798 }
1799 
1800 oop JvmtiExport::jni_GetField_probe(JavaThread *thread, jobject jobj, oop obj,
1801                                     Klass* klass, jfieldID fieldID, bool is_static) {
1802   if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) {
1803     // At least one field access watch is set so we have more work
1804     // to do. This wrapper is used by entry points that allow us
1805     // to create handles in post_field_access_by_jni().
1806     post_field_access_by_jni(thread, obj, klass, fieldID, is_static);
1807     // event posting can block so refetch oop if we were passed a jobj
1808     if (jobj != NULL) return JNIHandles::resolve_non_null(jobj);
1809   }
1810   return obj;
1811 }
1812 
1813 oop JvmtiExport::jni_GetField_probe_nh(JavaThread *thread, jobject jobj, oop obj,
1814                                        Klass* klass, jfieldID fieldID, bool is_static) {
1815   if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) {
1816     // At least one field access watch is set so we have more work
1817     // to do. This wrapper is used by "quick" entry points that don't
1818     // allow us to create handles in post_field_access_by_jni(). We
1819     // override that with a ResetNoHandleMark.
1820     ResetNoHandleMark rnhm;
1821     post_field_access_by_jni(thread, obj, klass, fieldID, is_static);
1822     // event posting can block so refetch oop if we were passed a jobj
1823     if (jobj != NULL) return JNIHandles::resolve_non_null(jobj);
1824   }
1825   return obj;
1826 }
1827 
1828 void JvmtiExport::post_field_access_by_jni(JavaThread *thread, oop obj,
1829                                            Klass* klass, jfieldID fieldID, bool is_static) {
1830   // We must be called with a Java context in order to provide reasonable
1831   // values for the klazz, method, and location fields. The callers of this
1832   // function don't make the call unless there is a Java context.
1833   assert(thread->has_last_Java_frame(), "must be called with a Java context");
1834 
1835   ResourceMark rm;
1836   fieldDescriptor fd;
1837   // if get_field_descriptor finds fieldID to be invalid, then we just bail
1838   bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd);
1839   assert(valid_fieldID == true,"post_field_access_by_jni called with invalid fieldID");
1840   if (!valid_fieldID) return;
1841   // field accesses are not watched so bail
1842   if (!fd.is_field_access_watched()) return;
1843 
1844   HandleMark hm(thread);
1845   Handle h_obj;
1846   if (!is_static) {
1847     // non-static field accessors have an object, but we need a handle
1848     assert(obj != NULL, "non-static needs an object");
1849     h_obj = Handle(thread, obj);
1850   }
1851   post_field_access(thread,
1852                     thread->last_frame().interpreter_frame_method(),
1853                     thread->last_frame().interpreter_frame_bcp(),
1854                     klass, h_obj, fieldID);
1855 }
1856 
1857 void JvmtiExport::post_field_access(JavaThread *thread, Method* method,
1858   address location, Klass* field_klass, Handle object, jfieldID field) {
1859 
1860   HandleMark hm(thread);
1861   methodHandle mh(thread, method);
1862 
1863   JvmtiThreadState *state = thread->jvmti_thread_state();
1864   if (state == NULL) {
1865     return;
1866   }
1867   EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Trg Field Access event triggered",
1868                       JvmtiTrace::safe_get_thread_name(thread)));
1869   JvmtiEnvThreadStateIterator it(state);
1870   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
1871     if (ets->is_enabled(JVMTI_EVENT_FIELD_ACCESS)) {
1872       EVT_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Evt Field Access event sent %s.%s @ " INTX_FORMAT,
1873                      JvmtiTrace::safe_get_thread_name(thread),
1874                      (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
1875                      (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
1876                      location - mh()->code_base() ));
1877 
1878       JvmtiEnv *env = ets->get_env();
1879       JvmtiLocationEventMark jem(thread, mh, location);
1880       jclass field_jclass = jem.to_jclass(field_klass);
1881       jobject field_jobject = jem.to_jobject(object());
1882       JvmtiJavaThreadEventTransition jet(thread);
1883       jvmtiEventFieldAccess callback = env->callbacks()->FieldAccess;
1884       if (callback != NULL) {
1885         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
1886                     jem.jni_methodID(), jem.location(),
1887                     field_jclass, field_jobject, field);
1888       }
1889     }
1890   }
1891 }
1892 
1893 oop JvmtiExport::jni_SetField_probe(JavaThread *thread, jobject jobj, oop obj,
1894                                     Klass* klass, jfieldID fieldID, bool is_static,
1895                                     char sig_type, jvalue *value) {
1896   if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) {
1897     // At least one field modification watch is set so we have more work
1898     // to do. This wrapper is used by entry points that allow us
1899     // to create handles in post_field_modification_by_jni().
1900     post_field_modification_by_jni(thread, obj, klass, fieldID, is_static, sig_type, value);
1901     // event posting can block so refetch oop if we were passed a jobj
1902     if (jobj != NULL) return JNIHandles::resolve_non_null(jobj);
1903   }
1904   return obj;
1905 }
1906 
1907 oop JvmtiExport::jni_SetField_probe_nh(JavaThread *thread, jobject jobj, oop obj,
1908                                        Klass* klass, jfieldID fieldID, bool is_static,
1909                                        char sig_type, jvalue *value) {
1910   if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) {
1911     // At least one field modification watch is set so we have more work
1912     // to do. This wrapper is used by "quick" entry points that don't
1913     // allow us to create handles in post_field_modification_by_jni(). We
1914     // override that with a ResetNoHandleMark.
1915     ResetNoHandleMark rnhm;
1916     post_field_modification_by_jni(thread, obj, klass, fieldID, is_static, sig_type, value);
1917     // event posting can block so refetch oop if we were passed a jobj
1918     if (jobj != NULL) return JNIHandles::resolve_non_null(jobj);
1919   }
1920   return obj;
1921 }
1922 
1923 void JvmtiExport::post_field_modification_by_jni(JavaThread *thread, oop obj,
1924                                                  Klass* klass, jfieldID fieldID, bool is_static,
1925                                                  char sig_type, jvalue *value) {
1926   // We must be called with a Java context in order to provide reasonable
1927   // values for the klazz, method, and location fields. The callers of this
1928   // function don't make the call unless there is a Java context.
1929   assert(thread->has_last_Java_frame(), "must be called with Java context");
1930 
1931   ResourceMark rm;
1932   fieldDescriptor fd;
1933   // if get_field_descriptor finds fieldID to be invalid, then we just bail
1934   bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd);
1935   assert(valid_fieldID == true,"post_field_modification_by_jni called with invalid fieldID");
1936   if (!valid_fieldID) return;
1937   // field modifications are not watched so bail
1938   if (!fd.is_field_modification_watched()) return;
1939 
1940   HandleMark hm(thread);
1941 
1942   Handle h_obj;
1943   if (!is_static) {
1944     // non-static field accessors have an object, but we need a handle
1945     assert(obj != NULL, "non-static needs an object");
1946     h_obj = Handle(thread, obj);
1947   }
1948   post_field_modification(thread,
1949                           thread->last_frame().interpreter_frame_method(),
1950                           thread->last_frame().interpreter_frame_bcp(),
1951                           klass, h_obj, fieldID, sig_type, value);
1952 }
1953 
1954 void JvmtiExport::post_raw_field_modification(JavaThread *thread, Method* method,
1955   address location, Klass* field_klass, Handle object, jfieldID field,
1956   char sig_type, jvalue *value) {
1957 
1958   if (sig_type == 'I' || sig_type == 'Z' || sig_type == 'B' || sig_type == 'C' || sig_type == 'S') {
1959     // 'I' instructions are used for byte, char, short and int.
1960     // determine which it really is, and convert
1961     fieldDescriptor fd;
1962     bool found = JvmtiEnv::get_field_descriptor(field_klass, field, &fd);
1963     // should be found (if not, leave as is)
1964     if (found) {
1965       jint ival = value->i;
1966       // convert value from int to appropriate type
1967       switch (fd.field_type()) {
1968       case T_BOOLEAN:
1969         sig_type = 'Z';
1970         value->i = 0; // clear it
1971         value->z = (jboolean)ival;
1972         break;
1973       case T_BYTE:
1974         sig_type = 'B';
1975         value->i = 0; // clear it
1976         value->b = (jbyte)ival;
1977         break;
1978       case T_CHAR:
1979         sig_type = 'C';
1980         value->i = 0; // clear it
1981         value->c = (jchar)ival;
1982         break;
1983       case T_SHORT:
1984         sig_type = 'S';
1985         value->i = 0; // clear it
1986         value->s = (jshort)ival;
1987         break;
1988       case T_INT:
1989         // nothing to do
1990         break;
1991       default:
1992         // this is an integer instruction, should be one of above
1993         ShouldNotReachHere();
1994         break;
1995       }
1996     }
1997   }
1998 
1999   assert(sig_type != '[', "array should have sig_type == 'L'");
2000   bool handle_created = false;
2001 
2002   // convert oop to JNI handle.
2003   if (sig_type == 'L') {
2004     handle_created = true;
2005     value->l = (jobject)JNIHandles::make_local(thread, (oop)value->l);
2006   }
2007 
2008   post_field_modification(thread, method, location, field_klass, object, field, sig_type, value);
2009 
2010   // Destroy the JNI handle allocated above.
2011   if (handle_created) {
2012     JNIHandles::destroy_local(value->l);
2013   }
2014 }
2015 
2016 void JvmtiExport::post_field_modification(JavaThread *thread, Method* method,
2017   address location, Klass* field_klass, Handle object, jfieldID field,
2018   char sig_type, jvalue *value_ptr) {
2019 
2020   HandleMark hm(thread);
2021   methodHandle mh(thread, method);
2022 
2023   JvmtiThreadState *state = thread->jvmti_thread_state();
2024   if (state == NULL) {
2025     return;
2026   }
2027   EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_MODIFICATION,
2028                      ("[%s] Trg Field Modification event triggered",
2029                       JvmtiTrace::safe_get_thread_name(thread)));
2030 
2031   JvmtiEnvThreadStateIterator it(state);
2032   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
2033     if (ets->is_enabled(JVMTI_EVENT_FIELD_MODIFICATION)) {
2034       EVT_TRACE(JVMTI_EVENT_FIELD_MODIFICATION,
2035                    ("[%s] Evt Field Modification event sent %s.%s @ " INTX_FORMAT,
2036                     JvmtiTrace::safe_get_thread_name(thread),
2037                     (mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(),
2038                     (mh() == NULL) ? "NULL" : mh()->name()->as_C_string(),
2039                     location - mh()->code_base() ));
2040 
2041       JvmtiEnv *env = ets->get_env();
2042       JvmtiLocationEventMark jem(thread, mh, location);
2043       jclass field_jclass = jem.to_jclass(field_klass);
2044       jobject field_jobject = jem.to_jobject(object());
2045       JvmtiJavaThreadEventTransition jet(thread);
2046       jvmtiEventFieldModification callback = env->callbacks()->FieldModification;
2047       if (callback != NULL) {
2048         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
2049                     jem.jni_methodID(), jem.location(),
2050                     field_jclass, field_jobject, field, sig_type, *value_ptr);
2051       }
2052     }
2053   }
2054 }
2055 
2056 void JvmtiExport::post_native_method_bind(Method* method, address* function_ptr) {
2057   JavaThread* thread = JavaThread::current();
2058   assert(thread->thread_state() == _thread_in_vm, "must be in vm state");
2059 
2060   HandleMark hm(thread);
2061   methodHandle mh(thread, method);
2062 
2063   EVT_TRIG_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Trg Native Method Bind event triggered",
2064                       JvmtiTrace::safe_get_thread_name(thread)));
2065 
2066   if (JvmtiEventController::is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) {
2067     JvmtiEnvIterator it;
2068     for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2069       if (env->is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) {
2070         EVT_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Evt Native Method Bind event sent",
2071                      JvmtiTrace::safe_get_thread_name(thread) ));
2072 
2073         JvmtiMethodEventMark jem(thread, mh);
2074         JvmtiJavaThreadEventTransition jet(thread);
2075         JNIEnv* jni_env = (env->phase() == JVMTI_PHASE_PRIMORDIAL) ? NULL : jem.jni_env();
2076         jvmtiEventNativeMethodBind callback = env->callbacks()->NativeMethodBind;
2077         if (callback != NULL) {
2078           (*callback)(env->jvmti_external(), jni_env, jem.jni_thread(),
2079                       jem.jni_methodID(), (void*)(*function_ptr), (void**)function_ptr);
2080         }
2081       }
2082     }
2083   }
2084 }
2085 
2086 // Returns a record containing inlining information for the given nmethod
2087 jvmtiCompiledMethodLoadInlineRecord* create_inline_record(nmethod* nm) {
2088   jint numstackframes = 0;
2089   jvmtiCompiledMethodLoadInlineRecord* record = (jvmtiCompiledMethodLoadInlineRecord*)NEW_RESOURCE_OBJ(jvmtiCompiledMethodLoadInlineRecord);
2090   record->header.kind = JVMTI_CMLR_INLINE_INFO;
2091   record->header.next = NULL;
2092   record->header.majorinfoversion = JVMTI_CMLR_MAJOR_VERSION_1;
2093   record->header.minorinfoversion = JVMTI_CMLR_MINOR_VERSION_0;
2094   record->numpcs = 0;
2095   for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) {
2096    if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue;
2097    record->numpcs++;
2098   }
2099   record->pcinfo = (PCStackInfo*)(NEW_RESOURCE_ARRAY(PCStackInfo, record->numpcs));
2100   int scope = 0;
2101   for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) {
2102     if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue;
2103     void* pc_address = (void*)p->real_pc(nm);
2104     assert(pc_address != NULL, "pc_address must be non-null");
2105     record->pcinfo[scope].pc = pc_address;
2106     numstackframes=0;
2107     for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != NULL;sd = sd->sender()) {
2108       numstackframes++;
2109     }
2110     assert(numstackframes != 0, "numstackframes must be nonzero.");
2111     record->pcinfo[scope].methods = (jmethodID *)NEW_RESOURCE_ARRAY(jmethodID, numstackframes);
2112     record->pcinfo[scope].bcis = (jint *)NEW_RESOURCE_ARRAY(jint, numstackframes);
2113     record->pcinfo[scope].numstackframes = numstackframes;
2114     int stackframe = 0;
2115     for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != NULL;sd = sd->sender()) {
2116       // sd->method() can be NULL for stubs but not for nmethods. To be completely robust, include an assert that we should never see a null sd->method()
2117       assert(sd->method() != NULL, "sd->method() cannot be null.");
2118       record->pcinfo[scope].methods[stackframe] = sd->method()->jmethod_id();
2119       record->pcinfo[scope].bcis[stackframe] = sd->bci();
2120       stackframe++;
2121     }
2122     scope++;
2123   }
2124   return record;
2125 }
2126 
2127 void JvmtiExport::post_compiled_method_load(nmethod *nm) {
2128   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
2129     return;
2130   }
2131   JavaThread* thread = JavaThread::current();
2132 
2133   EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD,
2134                  ("[%s] method compile load event triggered",
2135                  JvmtiTrace::safe_get_thread_name(thread)));
2136 
2137   JvmtiEnvIterator it;
2138   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2139     if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_LOAD)) {
2140       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
2141         continue;
2142       }
2143       EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD,
2144                 ("[%s] class compile method load event sent %s.%s  ",
2145                 JvmtiTrace::safe_get_thread_name(thread),
2146                 (nm->method() == NULL) ? "NULL" : nm->method()->klass_name()->as_C_string(),
2147                 (nm->method() == NULL) ? "NULL" : nm->method()->name()->as_C_string()));
2148       ResourceMark rm(thread);
2149       HandleMark hm(thread);
2150 
2151       // Add inlining information
2152       jvmtiCompiledMethodLoadInlineRecord* inlinerecord = create_inline_record(nm);
2153       // Pass inlining information through the void pointer
2154       JvmtiCompiledMethodLoadEventMark jem(thread, nm, inlinerecord);
2155       JvmtiJavaThreadEventTransition jet(thread);
2156       jvmtiEventCompiledMethodLoad callback = env->callbacks()->CompiledMethodLoad;
2157       if (callback != NULL) {
2158         (*callback)(env->jvmti_external(), jem.jni_methodID(),
2159                     jem.code_size(), jem.code_data(), jem.map_length(),
2160                     jem.map(), jem.compile_info());
2161       }
2162     }
2163   }
2164 }
2165 
2166 
2167 // post a COMPILED_METHOD_LOAD event for a given environment
2168 void JvmtiExport::post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
2169                                             const void *code_begin, const jint map_length,
2170                                             const jvmtiAddrLocationMap* map)
2171 {
2172   if (env->phase() <= JVMTI_PHASE_PRIMORDIAL) {
2173     return;
2174   }
2175   JavaThread* thread = JavaThread::current();
2176   EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD,
2177                  ("[%s] method compile load event triggered (by GenerateEvents)",
2178                  JvmtiTrace::safe_get_thread_name(thread)));
2179   if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_LOAD)) {
2180 
2181     EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD,
2182               ("[%s] class compile method load event sent (by GenerateEvents), jmethodID=" PTR_FORMAT,
2183                JvmtiTrace::safe_get_thread_name(thread), p2i(method)));
2184 
2185     JvmtiEventMark jem(thread);
2186     JvmtiJavaThreadEventTransition jet(thread);
2187     jvmtiEventCompiledMethodLoad callback = env->callbacks()->CompiledMethodLoad;
2188     if (callback != NULL) {
2189       (*callback)(env->jvmti_external(), method,
2190                   length, code_begin, map_length,
2191                   map, NULL);
2192     }
2193   }
2194 }
2195 
2196 void JvmtiExport::post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) {
2197   assert(name != NULL && name[0] != '\0', "sanity check");
2198 
2199   JavaThread* thread = JavaThread::current();
2200   // In theory everyone coming thru here is in_vm but we need to be certain
2201   // because a callee will do a vm->native transition
2202   ThreadInVMfromUnknown __tiv;
2203 
2204   EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
2205                  ("[%s] method dynamic code generated event triggered",
2206                  JvmtiTrace::safe_get_thread_name(thread)));
2207   JvmtiEnvIterator it;
2208   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2209     if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) {
2210       EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
2211                 ("[%s] dynamic code generated event sent for %s",
2212                 JvmtiTrace::safe_get_thread_name(thread), name));
2213       JvmtiEventMark jem(thread);
2214       JvmtiJavaThreadEventTransition jet(thread);
2215       jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char));
2216       jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated;
2217       if (callback != NULL) {
2218         (*callback)(env->jvmti_external(), name, (void*)code_begin, length);
2219       }
2220     }
2221   }
2222 }
2223 
2224 void JvmtiExport::post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) {
2225   jvmtiPhase phase = JvmtiEnv::get_phase();
2226   if (phase == JVMTI_PHASE_PRIMORDIAL || phase == JVMTI_PHASE_START) {
2227     post_dynamic_code_generated_internal(name, code_begin, code_end);
2228   } else {
2229     // It may not be safe to post the event from this thread.  Defer all
2230     // postings to the service thread so that it can perform them in a safe
2231     // context and in-order.
2232     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
2233     JvmtiDeferredEvent event = JvmtiDeferredEvent::dynamic_code_generated_event(
2234         name, code_begin, code_end);
2235     JvmtiDeferredEventQueue::enqueue(event);
2236   }
2237 }
2238 
2239 
2240 // post a DYNAMIC_CODE_GENERATED event for a given environment
2241 // used by GenerateEvents
2242 void JvmtiExport::post_dynamic_code_generated(JvmtiEnv* env, const char *name,
2243                                               const void *code_begin, const void *code_end)
2244 {
2245   JavaThread* thread = JavaThread::current();
2246   EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
2247                  ("[%s] dynamic code generated event triggered (by GenerateEvents)",
2248                   JvmtiTrace::safe_get_thread_name(thread)));
2249   if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) {
2250     EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
2251               ("[%s] dynamic code generated event sent for %s",
2252                JvmtiTrace::safe_get_thread_name(thread), name));
2253     JvmtiEventMark jem(thread);
2254     JvmtiJavaThreadEventTransition jet(thread);
2255     jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char));
2256     jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated;
2257     if (callback != NULL) {
2258       (*callback)(env->jvmti_external(), name, (void*)code_begin, length);
2259     }
2260   }
2261 }
2262 
2263 // post a DynamicCodeGenerated event while holding locks in the VM.
2264 void JvmtiExport::post_dynamic_code_generated_while_holding_locks(const char* name,
2265                                                                   address code_begin, address code_end)
2266 {
2267   // register the stub with the current dynamic code event collector
2268   JvmtiThreadState* state = JvmtiThreadState::state_for(JavaThread::current());
2269   // state can only be NULL if the current thread is exiting which
2270   // should not happen since we're trying to post an event
2271   guarantee(state != NULL, "attempt to register stub via an exiting thread");
2272   JvmtiDynamicCodeEventCollector* collector = state->get_dynamic_code_event_collector();
2273   guarantee(collector != NULL, "attempt to register stub without event collector");
2274   collector->register_stub(name, code_begin, code_end);
2275 }
2276 
2277 // Collect all the vm internally allocated objects which are visible to java world
2278 void JvmtiExport::record_vm_internal_object_allocation(oop obj) {
2279   Thread* thread = Thread::current_or_null();
2280   if (thread != NULL && thread->is_Java_thread())  {
2281     // Can not take safepoint here.
2282     NoSafepointVerifier no_sfpt;
2283     // Can not take safepoint here so can not use state_for to get
2284     // jvmti thread state.
2285     JvmtiThreadState *state = ((JavaThread*)thread)->jvmti_thread_state();
2286     if (state != NULL ) {
2287       // state is non NULL when VMObjectAllocEventCollector is enabled.
2288       JvmtiVMObjectAllocEventCollector *collector;
2289       collector = state->get_vm_object_alloc_event_collector();
2290       if (collector != NULL && collector->is_enabled()) {
2291         // Don't record classes as these will be notified via the ClassLoad
2292         // event.
2293         if (obj->klass() != SystemDictionary::Class_klass()) {
2294           collector->record_allocation(obj);
2295         }
2296       }
2297     }
2298   }
2299 }
2300 
2301 void JvmtiExport::post_garbage_collection_finish() {
2302   Thread *thread = Thread::current(); // this event is posted from VM-Thread.
2303   EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH,
2304                  ("[%s] garbage collection finish event triggered",
2305                   JvmtiTrace::safe_get_thread_name(thread)));
2306   JvmtiEnvIterator it;
2307   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2308     if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH)) {
2309       EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH,
2310                 ("[%s] garbage collection finish event sent",
2311                  JvmtiTrace::safe_get_thread_name(thread)));
2312       JvmtiThreadEventTransition jet(thread);
2313       // JNIEnv is NULL here because this event is posted from VM Thread
2314       jvmtiEventGarbageCollectionFinish callback = env->callbacks()->GarbageCollectionFinish;
2315       if (callback != NULL) {
2316         (*callback)(env->jvmti_external());
2317       }
2318     }
2319   }
2320 }
2321 
2322 void JvmtiExport::post_garbage_collection_start() {
2323   Thread* thread = Thread::current(); // this event is posted from vm-thread.
2324   EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START,
2325                  ("[%s] garbage collection start event triggered",
2326                   JvmtiTrace::safe_get_thread_name(thread)));
2327   JvmtiEnvIterator it;
2328   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2329     if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_START)) {
2330       EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START,
2331                 ("[%s] garbage collection start event sent",
2332                  JvmtiTrace::safe_get_thread_name(thread)));
2333       JvmtiThreadEventTransition jet(thread);
2334       // JNIEnv is NULL here because this event is posted from VM Thread
2335       jvmtiEventGarbageCollectionStart callback = env->callbacks()->GarbageCollectionStart;
2336       if (callback != NULL) {
2337         (*callback)(env->jvmti_external());
2338       }
2339     }
2340   }
2341 }
2342 
2343 void JvmtiExport::post_data_dump() {
2344   Thread *thread = Thread::current();
2345   EVT_TRIG_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST,
2346                  ("[%s] data dump request event triggered",
2347                   JvmtiTrace::safe_get_thread_name(thread)));
2348   JvmtiEnvIterator it;
2349   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2350     if (env->is_enabled(JVMTI_EVENT_DATA_DUMP_REQUEST)) {
2351       EVT_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST,
2352                 ("[%s] data dump request event sent",
2353                  JvmtiTrace::safe_get_thread_name(thread)));
2354      JvmtiThreadEventTransition jet(thread);
2355      // JNIEnv is NULL here because this event is posted from VM Thread
2356      jvmtiEventDataDumpRequest callback = env->callbacks()->DataDumpRequest;
2357      if (callback != NULL) {
2358        (*callback)(env->jvmti_external());
2359      }
2360     }
2361   }
2362 }
2363 
2364 void JvmtiExport::post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) {
2365   oop object = (oop)obj_mntr->object();
2366   if (!ServiceUtil::visible_oop(object)) {
2367     // Ignore monitor contended enter for vm internal object.
2368     return;
2369   }
2370   JvmtiThreadState *state = thread->jvmti_thread_state();
2371   if (state == NULL) {
2372     return;
2373   }
2374 
2375   HandleMark hm(thread);
2376   Handle h(thread, object);
2377 
2378   EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER,
2379                      ("[%s] montior contended enter event triggered",
2380                       JvmtiTrace::safe_get_thread_name(thread)));
2381 
2382   JvmtiEnvThreadStateIterator it(state);
2383   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
2384     if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTER)) {
2385       EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER,
2386                    ("[%s] monitor contended enter event sent",
2387                     JvmtiTrace::safe_get_thread_name(thread)));
2388       JvmtiMonitorEventMark  jem(thread, h());
2389       JvmtiEnv *env = ets->get_env();
2390       JvmtiThreadEventTransition jet(thread);
2391       jvmtiEventMonitorContendedEnter callback = env->callbacks()->MonitorContendedEnter;
2392       if (callback != NULL) {
2393         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object());
2394       }
2395     }
2396   }
2397 }
2398 
2399 void JvmtiExport::post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) {
2400   oop object = (oop)obj_mntr->object();
2401   if (!ServiceUtil::visible_oop(object)) {
2402     // Ignore monitor contended entered for vm internal object.
2403     return;
2404   }
2405   JvmtiThreadState *state = thread->jvmti_thread_state();
2406   if (state == NULL) {
2407     return;
2408   }
2409 
2410   HandleMark hm(thread);
2411   Handle h(thread, object);
2412 
2413   EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED,
2414                      ("[%s] montior contended entered event triggered",
2415                       JvmtiTrace::safe_get_thread_name(thread)));
2416 
2417   JvmtiEnvThreadStateIterator it(state);
2418   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
2419     if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED)) {
2420       EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED,
2421                    ("[%s] monitor contended enter event sent",
2422                     JvmtiTrace::safe_get_thread_name(thread)));
2423       JvmtiMonitorEventMark  jem(thread, h());
2424       JvmtiEnv *env = ets->get_env();
2425       JvmtiThreadEventTransition jet(thread);
2426       jvmtiEventMonitorContendedEntered callback = env->callbacks()->MonitorContendedEntered;
2427       if (callback != NULL) {
2428         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object());
2429       }
2430     }
2431   }
2432 }
2433 
2434 void JvmtiExport::post_monitor_wait(JavaThread *thread, oop object,
2435                                           jlong timeout) {
2436   JvmtiThreadState *state = thread->jvmti_thread_state();
2437   if (state == NULL) {
2438     return;
2439   }
2440 
2441   HandleMark hm(thread);
2442   Handle h(thread, object);
2443 
2444   EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAIT,
2445                      ("[%s] montior wait event triggered",
2446                       JvmtiTrace::safe_get_thread_name(thread)));
2447 
2448   JvmtiEnvThreadStateIterator it(state);
2449   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
2450     if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAIT)) {
2451       EVT_TRACE(JVMTI_EVENT_MONITOR_WAIT,
2452                    ("[%s] monitor wait event sent",
2453                     JvmtiTrace::safe_get_thread_name(thread)));
2454       JvmtiMonitorEventMark  jem(thread, h());
2455       JvmtiEnv *env = ets->get_env();
2456       JvmtiThreadEventTransition jet(thread);
2457       jvmtiEventMonitorWait callback = env->callbacks()->MonitorWait;
2458       if (callback != NULL) {
2459         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
2460                     jem.jni_object(), timeout);
2461       }
2462     }
2463   }
2464 }
2465 
2466 void JvmtiExport::post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) {
2467   oop object = (oop)obj_mntr->object();
2468   if (!ServiceUtil::visible_oop(object)) {
2469     // Ignore monitor waited for vm internal object.
2470     return;
2471   }
2472   JvmtiThreadState *state = thread->jvmti_thread_state();
2473   if (state == NULL) {
2474     return;
2475   }
2476 
2477   HandleMark hm(thread);
2478   Handle h(thread, object);
2479 
2480   EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAITED,
2481                      ("[%s] montior waited event triggered",
2482                       JvmtiTrace::safe_get_thread_name(thread)));
2483 
2484   JvmtiEnvThreadStateIterator it(state);
2485   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
2486     if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAITED)) {
2487       EVT_TRACE(JVMTI_EVENT_MONITOR_WAITED,
2488                    ("[%s] monitor waited event sent",
2489                     JvmtiTrace::safe_get_thread_name(thread)));
2490       JvmtiMonitorEventMark  jem(thread, h());
2491       JvmtiEnv *env = ets->get_env();
2492       JvmtiThreadEventTransition jet(thread);
2493       jvmtiEventMonitorWaited callback = env->callbacks()->MonitorWaited;
2494       if (callback != NULL) {
2495         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
2496                     jem.jni_object(), timed_out);
2497       }
2498     }
2499   }
2500 }
2501 
2502 
2503 void JvmtiExport::post_vm_object_alloc(JavaThread *thread,  oop object) {
2504   EVT_TRIG_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Trg vm object alloc triggered",
2505                       JvmtiTrace::safe_get_thread_name(thread)));
2506   if (object == NULL) {
2507     return;
2508   }
2509   HandleMark hm(thread);
2510   Handle h(thread, object);
2511   JvmtiEnvIterator it;
2512   for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
2513     if (env->is_enabled(JVMTI_EVENT_VM_OBJECT_ALLOC)) {
2514       EVT_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Evt vmobject alloc sent %s",
2515                                          JvmtiTrace::safe_get_thread_name(thread),
2516                                          object==NULL? "NULL" : object->klass()->external_name()));
2517 
2518       JvmtiVMObjectAllocEventMark jem(thread, h());
2519       JvmtiJavaThreadEventTransition jet(thread);
2520       jvmtiEventVMObjectAlloc callback = env->callbacks()->VMObjectAlloc;
2521       if (callback != NULL) {
2522         (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(),
2523                     jem.jni_jobject(), jem.jni_class(), jem.size());
2524       }
2525     }
2526   }
2527 }
2528 
2529 ////////////////////////////////////////////////////////////////////////////////////////////////
2530 
2531 void JvmtiExport::cleanup_thread(JavaThread* thread) {
2532   assert(JavaThread::current() == thread, "thread is not current");
2533   MutexLocker mu(JvmtiThreadState_lock);
2534 
2535   if (thread->jvmti_thread_state() != NULL) {
2536     // This has to happen after the thread state is removed, which is
2537     // why it is not in post_thread_end_event like its complement
2538     // Maybe both these functions should be rolled into the posts?
2539     JvmtiEventController::thread_ended(thread);
2540   }
2541 }
2542 
2543 void JvmtiExport::clear_detected_exception(JavaThread* thread) {
2544   assert(JavaThread::current() == thread, "thread is not current");
2545 
2546   JvmtiThreadState* state = thread->jvmti_thread_state();
2547   if (state != NULL) {
2548     state->clear_exception_state();
2549   }
2550 }
2551 
2552 void JvmtiExport::oops_do(OopClosure* f) {
2553   JvmtiCurrentBreakpoints::oops_do(f);
2554   JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(f);
2555 }
2556 
2557 void JvmtiExport::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) {
2558   JvmtiTagMap::weak_oops_do(is_alive, f);
2559 }
2560 
2561 void JvmtiExport::gc_epilogue() {
2562   JvmtiCurrentBreakpoints::gc_epilogue();
2563 }
2564 
2565 // Onload raw monitor transition.
2566 void JvmtiExport::transition_pending_onload_raw_monitors() {
2567   JvmtiPendingMonitors::transition_raw_monitors();
2568 }
2569 
2570 ////////////////////////////////////////////////////////////////////////////////////////////////
2571 #if INCLUDE_SERVICES
2572 // Attach is disabled if SERVICES is not included
2573 
2574 // type for the Agent_OnAttach entry point
2575 extern "C" {
2576   typedef jint (JNICALL *OnAttachEntry_t)(JavaVM*, char *, void *);
2577 }
2578 
2579 jint JvmtiExport::load_agent_library(const char *agent, const char *absParam,
2580                                      const char *options, outputStream* st) {
2581   char ebuf[1024];
2582   char buffer[JVM_MAXPATHLEN];
2583   void* library = NULL;
2584   jint result = JNI_ERR;
2585   const char *on_attach_symbols[] = AGENT_ONATTACH_SYMBOLS;
2586   size_t num_symbol_entries = ARRAY_SIZE(on_attach_symbols);
2587 
2588   // The abs paramter should be "true" or "false"
2589   bool is_absolute_path = (absParam != NULL) && (strcmp(absParam,"true")==0);
2590 
2591   // Initially marked as invalid. It will be set to valid if we can find the agent
2592   AgentLibrary *agent_lib = new AgentLibrary(agent, options, is_absolute_path, NULL);
2593 
2594   // Check for statically linked in agent. If not found then if the path is
2595   // absolute we attempt to load the library. Otherwise we try to load it
2596   // from the standard dll directory.
2597 
2598   if (!os::find_builtin_agent(agent_lib, on_attach_symbols, num_symbol_entries)) {
2599     if (is_absolute_path) {
2600       library = os::dll_load(agent, ebuf, sizeof ebuf);
2601     } else {
2602       // Try to load the agent from the standard dll directory
2603       if (os::dll_locate_lib(buffer, sizeof(buffer), Arguments::get_dll_dir(),
2604                              agent)) {
2605         library = os::dll_load(buffer, ebuf, sizeof ebuf);
2606       }
2607       if (library == NULL) {
2608         // not found - try OS default library path
2609         if (os::dll_build_name(buffer, sizeof(buffer), agent)) {
2610           library = os::dll_load(buffer, ebuf, sizeof ebuf);
2611         }
2612       }
2613     }
2614     if (library != NULL) {
2615       agent_lib->set_os_lib(library);
2616       agent_lib->set_valid();
2617     }
2618   }
2619   // If the library was loaded then we attempt to invoke the Agent_OnAttach
2620   // function
2621   if (agent_lib->valid()) {
2622     // Lookup the Agent_OnAttach function
2623     OnAttachEntry_t on_attach_entry = NULL;
2624     on_attach_entry = CAST_TO_FN_PTR(OnAttachEntry_t,
2625        os::find_agent_function(agent_lib, false, on_attach_symbols, num_symbol_entries));
2626     if (on_attach_entry == NULL) {
2627       // Agent_OnAttach missing - unload library
2628       if (!agent_lib->is_static_lib()) {
2629         os::dll_unload(library);
2630       }
2631       delete agent_lib;
2632     } else {
2633       // Invoke the Agent_OnAttach function
2634       JavaThread* THREAD = JavaThread::current();
2635       {
2636         extern struct JavaVM_ main_vm;
2637         JvmtiThreadEventMark jem(THREAD);
2638         JvmtiJavaThreadEventTransition jet(THREAD);
2639 
2640         result = (*on_attach_entry)(&main_vm, (char*)options, NULL);
2641       }
2642 
2643       // Agent_OnAttach may have used JNI
2644       if (HAS_PENDING_EXCEPTION) {
2645         CLEAR_PENDING_EXCEPTION;
2646       }
2647 
2648       // If OnAttach returns JNI_OK then we add it to the list of
2649       // agent libraries so that we can call Agent_OnUnload later.
2650       if (result == JNI_OK) {
2651         Arguments::add_loaded_agent(agent_lib);
2652       } else {
2653         delete agent_lib;
2654       }
2655 
2656       // Agent_OnAttach executed so completion status is JNI_OK
2657       st->print_cr("%d", result);
2658       result = JNI_OK;
2659     }
2660   }
2661   return result;
2662 }
2663 
2664 #endif // INCLUDE_SERVICES
2665 ////////////////////////////////////////////////////////////////////////////////////////////////
2666 
2667 // Setup current current thread for event collection.
2668 void JvmtiEventCollector::setup_jvmti_thread_state() {
2669   // set this event collector to be the current one.
2670   JvmtiThreadState* state = JvmtiThreadState::state_for(JavaThread::current());
2671   // state can only be NULL if the current thread is exiting which
2672   // should not happen since we're trying to configure for event collection
2673   guarantee(state != NULL, "exiting thread called setup_jvmti_thread_state");
2674   if (is_vm_object_alloc_event()) {
2675     _prev = state->get_vm_object_alloc_event_collector();
2676     state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)this);
2677   } else if (is_dynamic_code_event()) {
2678     _prev = state->get_dynamic_code_event_collector();
2679     state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)this);
2680   }
2681 }
2682 
2683 // Unset current event collection in this thread and reset it with previous
2684 // collector.
2685 void JvmtiEventCollector::unset_jvmti_thread_state() {
2686   JvmtiThreadState* state = JavaThread::current()->jvmti_thread_state();
2687   if (state != NULL) {
2688     // restore the previous event collector (if any)
2689     if (is_vm_object_alloc_event()) {
2690       if (state->get_vm_object_alloc_event_collector() == this) {
2691         state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)_prev);
2692       } else {
2693         // this thread's jvmti state was created during the scope of
2694         // the event collector.
2695       }
2696     } else {
2697       if (is_dynamic_code_event()) {
2698         if (state->get_dynamic_code_event_collector() == this) {
2699           state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)_prev);
2700         } else {
2701           // this thread's jvmti state was created during the scope of
2702           // the event collector.
2703         }
2704       }
2705     }
2706   }
2707 }
2708 
2709 // create the dynamic code event collector
2710 JvmtiDynamicCodeEventCollector::JvmtiDynamicCodeEventCollector() : _code_blobs(NULL) {
2711   if (JvmtiExport::should_post_dynamic_code_generated()) {
2712     setup_jvmti_thread_state();
2713   }
2714 }
2715 
2716 // iterate over any code blob descriptors collected and post a
2717 // DYNAMIC_CODE_GENERATED event to the profiler.
2718 JvmtiDynamicCodeEventCollector::~JvmtiDynamicCodeEventCollector() {
2719   assert(!JavaThread::current()->owns_locks(), "all locks must be released to post deferred events");
2720  // iterate over any code blob descriptors that we collected
2721  if (_code_blobs != NULL) {
2722    for (int i=0; i<_code_blobs->length(); i++) {
2723      JvmtiCodeBlobDesc* blob = _code_blobs->at(i);
2724      JvmtiExport::post_dynamic_code_generated(blob->name(), blob->code_begin(), blob->code_end());
2725      FreeHeap(blob);
2726    }
2727    delete _code_blobs;
2728  }
2729  unset_jvmti_thread_state();
2730 }
2731 
2732 // register a stub
2733 void JvmtiDynamicCodeEventCollector::register_stub(const char* name, address start, address end) {
2734  if (_code_blobs == NULL) {
2735    _code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiCodeBlobDesc*>(1,true);
2736  }
2737  _code_blobs->append(new JvmtiCodeBlobDesc(name, start, end));
2738 }
2739 
2740 // Setup current thread to record vm allocated objects.
2741 JvmtiVMObjectAllocEventCollector::JvmtiVMObjectAllocEventCollector() : _allocated(NULL) {
2742   if (JvmtiExport::should_post_vm_object_alloc()) {
2743     _enable = true;
2744     setup_jvmti_thread_state();
2745   } else {
2746     _enable = false;
2747   }
2748 }
2749 
2750 // Post vm_object_alloc event for vm allocated objects visible to java
2751 // world.
2752 JvmtiVMObjectAllocEventCollector::~JvmtiVMObjectAllocEventCollector() {
2753   if (_allocated != NULL) {
2754     set_enabled(false);
2755     for (int i = 0; i < _allocated->length(); i++) {
2756       oop obj = _allocated->at(i);
2757       if (ServiceUtil::visible_oop(obj)) {
2758         JvmtiExport::post_vm_object_alloc(JavaThread::current(), obj);
2759       }
2760     }
2761     delete _allocated;
2762   }
2763   unset_jvmti_thread_state();
2764 }
2765 
2766 void JvmtiVMObjectAllocEventCollector::record_allocation(oop obj) {
2767   assert(is_enabled(), "VM object alloc event collector is not enabled");
2768   if (_allocated == NULL) {
2769     _allocated = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<oop>(1, true);
2770   }
2771   _allocated->push(obj);
2772 }
2773 
2774 // GC support.
2775 void JvmtiVMObjectAllocEventCollector::oops_do(OopClosure* f) {
2776   if (_allocated != NULL) {
2777     for(int i=_allocated->length() - 1; i >= 0; i--) {
2778       if (_allocated->at(i) != NULL) {
2779         f->do_oop(_allocated->adr_at(i));
2780       }
2781     }
2782   }
2783 }
2784 
2785 void JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(OopClosure* f) {
2786   // no-op if jvmti not enabled
2787   if (!JvmtiEnv::environments_might_exist()) {
2788     return;
2789   }
2790 
2791   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *jthr = jtiwh.next(); ) {

2792     JvmtiThreadState *state = jthr->jvmti_thread_state();
2793     if (state != NULL) {
2794       JvmtiVMObjectAllocEventCollector *collector;
2795       collector = state->get_vm_object_alloc_event_collector();
2796       while (collector != NULL) {
2797         collector->oops_do(f);
2798         collector = (JvmtiVMObjectAllocEventCollector *)collector->get_prev();
2799       }
2800     }
2801   }
2802 }
2803 
2804 
2805 // Disable collection of VMObjectAlloc events
2806 NoJvmtiVMObjectAllocMark::NoJvmtiVMObjectAllocMark() : _collector(NULL) {
2807   // a no-op if VMObjectAlloc event is not enabled
2808   if (!JvmtiExport::should_post_vm_object_alloc()) {
2809     return;
2810   }
2811   Thread* thread = Thread::current_or_null();
2812   if (thread != NULL && thread->is_Java_thread())  {
2813     JavaThread* current_thread = (JavaThread*)thread;
2814     JvmtiThreadState *state = current_thread->jvmti_thread_state();
2815     if (state != NULL) {
2816       JvmtiVMObjectAllocEventCollector *collector;
2817       collector = state->get_vm_object_alloc_event_collector();
2818       if (collector != NULL && collector->is_enabled()) {
2819         _collector = collector;
2820         _collector->set_enabled(false);
2821       }
2822     }
2823   }
2824 }
2825 
2826 // Re-Enable collection of VMObjectAlloc events (if previously enabled)
2827 NoJvmtiVMObjectAllocMark::~NoJvmtiVMObjectAllocMark() {
2828   if (was_enabled()) {
2829     _collector->set_enabled(true);
2830   }
2831 };
2832 
2833 JvmtiGCMarker::JvmtiGCMarker() {
2834   // if there aren't any JVMTI environments then nothing to do
2835   if (!JvmtiEnv::environments_might_exist()) {
2836     return;
2837   }
2838 
2839   if (JvmtiExport::should_post_garbage_collection_start()) {
2840     JvmtiExport::post_garbage_collection_start();
2841   }
2842 
2843   if (SafepointSynchronize::is_at_safepoint()) {
2844     // Do clean up tasks that need to be done at a safepoint
2845     JvmtiEnvBase::check_for_periodic_clean_up();
2846   }
2847 }
2848 
2849 JvmtiGCMarker::~JvmtiGCMarker() {
2850   // if there aren't any JVMTI environments then nothing to do
2851   if (!JvmtiEnv::environments_might_exist()) {
2852     return;
2853   }
2854 
2855   // JVMTI notify gc finish
2856   if (JvmtiExport::should_post_garbage_collection_finish()) {
2857     JvmtiExport::post_garbage_collection_finish();
2858   }
2859 }
--- EOF ---