((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // The following classes are C++ `closures` for iterating over objects, roots and spaces

    Closure (abstract)
      OopClosure (abstract)
        OopsInGenClosure (abstract)
        ... (いっぱいサブクラスがある)
      ObjectClosure (abstract)
        ... (いっぱいサブクラスがある)
      CodeBlobClosure (abstract)
        MarkingCodeBlobClosure (abstract)
          CodeBlobToOopClosure
        MarkActivationClosure

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // Closure provides abortability.

    class Closure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // OopClosure is used for iterating through roots (oop*)

    class OopClosure : public Closure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual void do_oop(oop* o) = 0;
      virtual void do_oop_v(oop* o) { do_oop(o); }
      virtual void do_oop(narrowOop* o) = 0;
      virtual void do_oop_v(narrowOop* o) { do_oop(o); }

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // ObjectClosure is used for iterating through an object space

    class ObjectClosure : public Closure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Called for each object.
      virtual void do_object(oop obj) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    class BoolObjectClosure : public ObjectClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual bool do_object_b(oop obj) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // Applies an oop closure to all ref fields in objects iterated over in an
    // object iteration.
    class ObjectToOopClosure: public ObjectClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      ObjectToOopClosure(OopClosure* cl) : _cl(cl) {}

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // A version of ObjectClosure with "memory" (see _previous_address below)
    class UpwardsObjectClosure: public BoolObjectClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      HeapWord* _previous_address;
    ...
      UpwardsObjectClosure() : _previous_address(NULL) { }
      void set_previous(HeapWord* addr) { _previous_address = addr; }
      HeapWord* previous()              { return _previous_address; }

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // A return value of "true" can be used by the caller to decide
      // if this object's end should *NOT* be recorded in
      // _previous_address above.
      virtual bool do_object_bm(oop obj, MemRegion mr) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // A version of ObjectClosure that is expected to be robust
    // in the face of possibly uninitialized objects.
    class ObjectClosureCareful : public ObjectClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual size_t do_object_careful_m(oop p, MemRegion mr) = 0;
      virtual size_t do_object_careful(oop p) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // Blk closure (abstract class)
    class BlkClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // The following are used in CompactibleFreeListSpace and
    // ConcurrentMarkSweepGeneration.

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual size_t do_blk(HeapWord* addr) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // A version of BlkClosure that is expected to be robust
    // in the face of possibly uninitialized objects.
    class BlkClosureCareful : public BlkClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // The following are used in CompactibleFreeListSpace and
    // ConcurrentMarkSweepGeneration.

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual size_t do_blk_careful(HeapWord* addr) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      size_t do_blk(HeapWord* addr) {
        guarantee(false, "call do_blk_careful instead");
        return 0;
      }

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // SpaceClosure is used for iterating over spaces
    ...
    class SpaceClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Called for each space
      virtual void do_space(Space* s) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    class CompactibleSpaceClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Called for each compactible space
      virtual void do_space(CompactibleSpace* s) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // CodeBlobClosure is used for iterating through code blobs
    // in the code cache or on thread stacks

    class CodeBlobClosure : public Closure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Called for each code blob.
      virtual void do_code_blob(CodeBlob* cb) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    class MarkingCodeBlobClosure : public CodeBlobClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Called for each code blob, but at most once per unique blob.
      virtual void do_newly_marked_nmethod(nmethod* nm) = 0;

      virtual void do_code_blob(CodeBlob* cb);

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      class MarkScope : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.cpp))
    MarkingCodeBlobClosure::MarkScope::MarkScope(bool activate)
      : _active(activate)
    {
      if (_active)  nmethod::oops_do_marking_prologue();
    }

    MarkingCodeBlobClosure::MarkScope::~MarkScope() {
      if (_active)  nmethod::oops_do_marking_epilogue();
    }

    ((cite: hotspot/src/share/vm/code/nmethod.cpp))
    #define NMETHOD_SENTINEL ((nmethod*)badAddress)

    nmethod* volatile nmethod::_oops_do_mark_nmethods;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // Applies an oop closure to all ref fields in code blobs
    // iterated over in an object iteration.
    class CodeBlobToOopClosure: public MarkingCodeBlobClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      CodeBlobToOopClosure(OopClosure* cl, bool do_marking)

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual void do_newly_marked_nmethod(nmethod* cb);
        // = { cb->oops_do(_cl); }
      virtual void do_code_blob(CodeBlob* cb);
        // = { if (_do_marking)  super::do_code_blob(cb); else cb->oops_do(_cl); }

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // MonitorClosure is used for iterating over monitors in the monitors cache
    ...
    class MonitorClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // called for each monitor in cache
      virtual void do_monitor(ObjectMonitor* m) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // A closure that is applied without any arguments.
    class VoidClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // I would have liked to declare this a pure virtual, but that breaks
      // in mysterious ways, for unknown reasons.
      virtual void do_void();

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // YieldClosure is intended for use by iteration loops
    // to incrementalize their work, allowing interleaving
    // of an interruptable task so as to allow other
    // threads to run (which may not otherwise be able to access
    // exclusive resources, for instance). Additionally, the
    // closure also allows for aborting an ongoing iteration
    // by means of checking the return value from the polling
    // call.
    class YieldClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
       virtual bool should_return() = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    // Abstract closure for serializing data (read or write).

    class SerializeOopClosure : public OopClosure {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      // Return bool indicating whether closure implements read or write.
      virtual bool reading() const = 0;

      // Read/write the int pointed to by i.
      virtual void do_int(int* i) = 0;

      // Read/write the size_t pointed to by i.
      virtual void do_size_t(size_t* i) = 0;

      // Read/write the void pointer pointed to by p.
      virtual void do_ptr(void** p) = 0;

      // Read/write the HeapWord pointer pointed to be p.
      virtual void do_ptr(HeapWord** p) = 0;

      // Read/write the region specified.
      virtual void do_region(u_char* start, size_t size) = 0;

      // Check/write the tag.  If reading, then compare the tag against
      // the passed in value and fail is they don't match.  This allows
      // for verification that sections of the serialized data are of the
      // correct length.
      virtual void do_tag(int tag) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    class SymbolClosure : public StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual void do_symbol(Symbol**) = 0;

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
    #ifdef ASSERT
    // This class is used to flag phases of a collection that
    // can unload classes and which should override the
    // should_remember_klasses() and remember_klass() of OopClosure.
    // The _must_remember_klasses is set in the contructor and restored
    // in the destructor.  _must_remember_klasses is checked in assertions
    // in the OopClosure implementations of should_remember_klasses() and
    // remember_klass() and the expectation is that the OopClosure
    // implementation should not be in use if _must_remember_klasses is set.
    // Instances of RememberKlassesChecker can be place in
    // marking phases of collections which can do class unloading.
    // RememberKlassesChecker can be passed "false" to turn off checking.
    // It is used by CMS when CMS yields to a different collector.
    class RememberKlassesChecker: StackObj {

    ((cite: hotspot/src/share/vm/memory/iterator.cpp))
    #ifdef ASSERT
    bool OopClosure::_must_remember_klasses = false;
    #endif

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      RememberKlassesChecker(bool checking_on) : _saved_state(false),
        _do_check(true) {
        // The ClassUnloading unloading flag affects the collectors except
        // for CMS.
        // CMS unloads classes if CMSClassUnloadingEnabled is true or
        // if ExplicitGCInvokesConcurrentAndUnloadsClasses is true and
        // the current collection is an explicit collection.  Turning
        // on the checking in general for
        // ExplicitGCInvokesConcurrentAndUnloadsClasses and
        // UseConcMarkSweepGC should not lead to false positives.
        _do_check =
          ClassUnloading && !UseConcMarkSweepGC ||
          CMSClassUnloadingEnabled && UseConcMarkSweepGC ||
          ExplicitGCInvokesConcurrentAndUnloadsClasses && UseConcMarkSweepGC;
        if (_do_check) {
          _saved_state = OopClosure::must_remember_klasses();
          OopClosure::set_must_remember_klasses(checking_on);
        }
      }
      ~RememberKlassesChecker() {
        if (_do_check) {
          OopClosure::set_must_remember_klasses(_saved_state);
        }
      }

    ((cite: hotspot/src/share/vm/memory/iterator.hpp))
      virtual void remember_klass(Klass* k) { /* do nothing */ }