((cite: hotspot/src/share/vm/memory/resourceArea.hpp))
    //------------------------------ResourceArea-----------------------------------
    // A ResourceArea is an Arena that supports safe usage of ResourceMark.
    class ResourceArea: public Arena {

    ((cite: hotspot/src/share/vm/memory/resourceArea.hpp))
    //------------------------------ResourceMark-----------------------------------
    // A resource mark releases all resources allocated after it was constructed
    // when the destructor is called.  Typically used as a local variable.
    class ResourceMark: public StackObj {

    ((cite: hotspot/src/share/vm/memory/resourceArea.hpp))
      ResourceMark()               { initialize(Thread::current()); }

    ((cite: hotspot/src/share/vm/memory/resourceArea.hpp))
    //------------------------------DeoptResourceMark-----------------------------------
    // A deopt resource mark releases all resources allocated after it was constructed
    // when the destructor is called.  Typically used as a local variable. It differs
    // from a typical resource more in that it is C-Heap allocated so that deoptimization
    // can use data structures that are arena based but are not amenable to vanilla
    // ResourceMarks because deoptimization can not use a stack allocated mark. During
    // deoptimization we go thru the following steps:
    //
    // 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
    // 1: create the vframeArray (contains pointers to Resource allocated structures)
    //   This allocates the DeoptResourceMark.
    // 2: return to assembly stub and remove stub frame and deoptee frame and create
    //    the new skeletal frames.
    // 3: push new stub frame and call unpack_frames
    // 4: retrieve information from the vframeArray to populate the skeletal frames
    // 5: release the DeoptResourceMark
    // 6: return to stub and eventually to interpreter
    //
    // With old style eager deoptimization the vframeArray was created by the vmThread there
    // was no way for the vframeArray to contain resource allocated objects and so
    // a complex set of data structures to simulate an array of vframes in CHeap memory
    // was used. With new style lazy deoptimization the vframeArray is created in the
    // the thread that will use it and we can use a much simpler scheme for the vframeArray
    // leveraging existing data structures if we simply create a way to manage this one
    // special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
    // then existing ResourceMarks would work fine since no one use new to allocate them
    // and they would be stack allocated. This leaves open the possibilty of accidental
    // misuse so we simple duplicate the ResourceMark functionality here.

    class DeoptResourceMark: public CHeapObj {

    ((cite: hotspot/src/share/vm/runtime/thread.hpp))
    class JavaThread: public Thread {
    ...
      // Deopt support
      DeoptResourceMark*  _deopt_mark;               // Holds special ResourceMark for deoptimization

    ((cite: hotspot/src/share/vm/runtime/deoptimization.cpp))
    Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread* thread) {
    ...
      // Allocate our special deoptimization ResourceMark
      DeoptResourceMark* dmark = new DeoptResourceMark(thread);
      assert(thread->deopt_mark() == NULL, "Pending deopt!");
      thread->set_deopt_mark(dmark);

    ((cite: hotspot/src/share/vm/runtime/deoptimization.cpp))
    void Deoptimization::cleanup_deopt_info(JavaThread *thread,
                                            vframeArray *array) {
    ...
      // Deallocate any resource creating in this routine and any ResourceObjs allocated
      // inside the vframeArray (StackValueCollections)

      delete thread->deopt_mark();
      thread->set_deopt_mark(NULL);
      thread->set_deopt_nmethod(NULL);