((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class GrowableCache, GrowableElement
    // Used by              : JvmtiBreakpointCache
    // Used by JVMTI methods: none directly.
    //
    // GrowableCache is a permanent CHeap growable array of <GrowableElement *>
    //
    // In addition, the GrowableCache maintains a NULL terminated cache array of type address
    // that's created from the element array using the function:
    //     address GrowableElement::getCacheValue().
    //
    // Whenever the GrowableArray changes size, the cache array gets recomputed into a new C_HEAP allocated
    // block of memory. Additionally, every time the cache changes its position in memory, the
    //    void (*_listener_fun)(void *this_obj, address* cache)
    // gets called with the cache's new address. This gives the user of the GrowableCache a callback
    // to update its pointer to the address cache.
    //

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    class GrowableElement : public CHeapObj {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class GrowableCache, GrowableElement
    // Used by              : JvmtiBreakpointCache
    // Used by JVMTI methods: none directly.
    //
    // GrowableCache is a permanent CHeap growable array of <GrowableElement *>
    //
    // In addition, the GrowableCache maintains a NULL terminated cache array of type address
    // that's created from the element array using the function:
    //     address GrowableElement::getCacheValue().
    //
    // Whenever the GrowableArray changes size, the cache array gets recomputed into a new C_HEAP allocated
    // block of memory. Additionally, every time the cache changes its position in memory, the
    //    void (*_listener_fun)(void *this_obj, address* cache)
    // gets called with the cache's new address. This gives the user of the GrowableCache a callback
    // to update its pointer to the address cache.
    //

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    class GrowableCache VALUE_OBJ_CLASS_SPEC {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      // Parallel array of cached values
      address *_cache;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      address getCacheValue()         { return getBcp(); }

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.cpp))
    address JvmtiBreakpoint::getBcp() {
      return _method->bcp_from(_bci);
    }

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class JvmtiBreakpointCache
    // Used by              : JvmtiBreakpoints
    // Used by JVMTI methods: none directly.
    // Note   : typesafe wrapper for GrowableCache of JvmtiBreakpoint
    //

    class JvmtiBreakpointCache : public CHeapObj {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class JvmtiBreakpoint
    // Used by              : JvmtiBreakpoints
    // Used by JVMTI methods: SetBreakpoint, ClearBreakpoint, ClearAllBreakpoints
    // Note: Extends GrowableElement for use in a GrowableCache
    //
    // A JvmtiBreakpoint describes a location (class, method, bci) to break at.
    //

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    class JvmtiBreakpoint : public GrowableElement {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class VM_ChangeBreakpoints
    // Used by              : JvmtiBreakpoints
    // Used by JVMTI methods: none directly.
    // Note: A Helper class.
    //
    // VM_ChangeBreakpoints implements a VM_Operation for ALL modifications to the JvmtiBreakpoints class.
    //

    class VM_ChangeBreakpoints : public VM_Operation {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class JvmtiBreakpoints
    // Used by              : JvmtiCurrentBreakpoints
    // Used by JVMTI methods: none directly
    // Note: A Helper class
    //
    // JvmtiBreakpoints is a GrowableCache of JvmtiBreakpoint.
    // All changes to the GrowableCache occur at a safepoint using VM_ChangeBreakpoints.
    //
    // Because _bps is only modified at safepoints, its possible to always use the
    // cached byte code pointers from _bps without doing any synchronization (see JvmtiCurrentBreakpoints).
    //
    // It would be possible to make JvmtiBreakpoints a static class, but I've made it
    // CHeap allocated to emphasize its similarity to JvmtiFramePops.
    //

    class JvmtiBreakpoints : public CHeapObj {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      JvmtiBreakpointCache _bps;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class JvmtiCurrentBreakpoints
    //
    // A static wrapper class for the JvmtiBreakpoints that provides:
    // 1. a fast inlined function to check if a byte code pointer is a breakpoint (is_breakpoint).
    // 2. a function for lazily creating the JvmtiBreakpoints class (this is not strictly necessary,
    //    but I'm copying the code from JvmtiThreadState which needs to lazily initialize
    //    JvmtiFramePops).
    // 3. An oops_do entry point for GC'ing the breakpoint array.
    //

    class JvmtiCurrentBreakpoints : public AllStatic {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      static void initialize();
      static void destroy();

      // lazily create _jvmti_breakpoints and _breakpoint_list
      static JvmtiBreakpoints& get_jvmti_breakpoints();

      // quickly test whether the bcp matches a cached breakpoint in the list
      static inline bool is_breakpoint(address bcp);

      static void oops_do(OopClosure* f);
      static void gc_epilogue();

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    // The get/set local operations must only be done by the VM thread
    // because the interpreter version needs to access oop maps, which can
    // only safely be done by the VM thread
    //
    // I'm told that in 1.5 oop maps are now protected by a lock and
    // we could get rid of the VM op
    // However if the VM op is removed then the target thread must
    // be suspended AND a lock will be needed to prevent concurrent
    // setting of locals to the same java thread. This lock is needed
    // to prevent compiledVFrames from trying to add deferred updates
    // to the thread simultaneously.
    //
    class VM_GetOrSetLocal : public VM_Operation {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    class VM_GetReceiver : public VM_GetOrSetLocal {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    ///////////////////////////////////////////////////////////////
    //
    // class JvmtiSuspendControl
    //
    // Convenience routines for suspending and resuming threads.
    //
    // All attempts by JVMTI to suspend and resume threads must go through the
    // JvmtiSuspendControl interface.
    //
    // methods return true if successful
    //
    class JvmtiSuspendControl : public AllStatic {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      // suspend the thread, taking it to a safepoint
      static bool suspend(JavaThread *java_thread);
      // resume the thread
      static bool resume(JavaThread *java_thread);

      static void print();

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    class JvmtiDeferredEvent VALUE_OBJ_CLASS_SPEC {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      Type _type;
      union {
        nmethod* compiled_method_load;
        struct {
          nmethod* nm;
          jmethodID method_id;
          const void* code_begin;
        } compiled_method_unload;
        struct {
          const char* name;
          const void* code_begin;
          const void* code_end;
        } dynamic_code_generated;
      } _event_data;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      typedef enum {
        TYPE_NONE,
        TYPE_COMPILED_METHOD_LOAD,
        TYPE_COMPILED_METHOD_UNLOAD,
        TYPE_DYNAMIC_CODE_GENERATED
      } Type;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
    /**
     * Events enqueued on this queue wake up the Service thread which dequeues
     * and posts the events.  The Service_lock is required to be held
     * when operating on the queue (except for the "pending" events).
     */
    class JvmtiDeferredEventQueue : AllStatic {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      static QueueNode* _queue_head;             // Hold Service_lock to access
      static QueueNode* _queue_tail;             // Hold Service_lock to access
      static volatile QueueNode* _pending_list;  // Uses CAS for read/update

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      // Must be holding Service_lock when calling these
      static bool has_events() KERNEL_RETURN_(false);
      static void enqueue(const JvmtiDeferredEvent& event) KERNEL_RETURN;
      static JvmtiDeferredEvent dequeue() KERNEL_RETURN_(JvmtiDeferredEvent());

      // Used to enqueue events without using a lock, for times (such as during
      // safepoint) when we can't or don't want to lock the Service_lock.
      //
      // Events will be held off to the side until there's a call to
      // dequeue(), enqueue(), or process_pending_events() (all of which require
      // the holding of the Service_lock), and will be enqueued at that time.
      static void add_pending_event(const JvmtiDeferredEvent&) KERNEL_RETURN;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      // Transfers events from the _pending_list to the _queue.
      static void process_pending_events() KERNEL_RETURN;

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
      class QueueNode : public CHeapObj {

    ((cite: hotspot/src/share/vm/prims/jvmtiImpl.hpp))
        JvmtiDeferredEvent _event;
        QueueNode* _next;