src/share/vm/gc/g1/g1HeapVerifier.cpp

*** 254,264 ****
      assert(o != NULL, "Should not be here for NULL oops");
      o->oop_iterate_no_header(&checkOop);
    }
  };
  
! class VerifyRegionClosure: public HeapRegionClosure {
  private:
    bool             _par;
    VerifyOption     _vo;
    bool             _failures;
  public:
--- 254,264 ----
      assert(o != NULL, "Should not be here for NULL oops");
      o->oop_iterate_no_header(&checkOop);
    }
  };
  
! class VerifyRegionClosure: public AbortableHeapRegionClosure {
  private:
    bool             _par;
    VerifyOption     _vo;
    bool             _failures;
  public:
*** 272,282 ****
  
    bool failures() {
      return _failures;
    }
  
!   bool doHeapRegion(HeapRegion* r) {
      // For archive regions, verify there are no heap pointers to
      // non-pinned regions. For all others, verify liveness info.
      if (r->is_archive()) {
        VerifyArchiveRegionClosure verify_oop_pointers(r);
        r->object_iterate(&verify_oop_pointers);
--- 272,282 ----
  
    bool failures() {
      return _failures;
    }
  
!   bool doHeapRegionAbortable(HeapRegion* r) {
      // For archive regions, verify there are no heap pointers to
      // non-pinned regions. For all others, verify liveness info.
      if (r->is_archive()) {
        VerifyArchiveRegionClosure verify_oop_pointers(r);
        r->object_iterate(&verify_oop_pointers);
*** 430,440 ****
                             HeapRegionSet* humongous_set,
                             HeapRegionManager* hrm) :
      _old_set(old_set), _humongous_set(humongous_set), _hrm(hrm),
      _old_count(), _humongous_count(), _free_count(){ }
  
!   bool doHeapRegion(HeapRegion* hr) {
      if (hr->is_young()) {
        // TODO
      } else if (hr->is_humongous()) {
        assert(hr->containing_set() == _humongous_set, "Heap region %u is humongous but not in humongous set.", hr->hrm_index());
        _humongous_count++;
--- 430,440 ----
                             HeapRegionSet* humongous_set,
                             HeapRegionManager* hrm) :
      _old_set(old_set), _humongous_set(humongous_set), _hrm(hrm),
      _old_count(), _humongous_count(), _free_count(){ }
  
!   void doHeapRegion(HeapRegion* hr) {
      if (hr->is_young()) {
        // TODO
      } else if (hr->is_humongous()) {
        assert(hr->containing_set() == _humongous_set, "Heap region %u is humongous but not in humongous set.", hr->hrm_index());
        _humongous_count++;
*** 448,458 ****
        // There are no other valid region types. Check for one invalid
        // one we can identify: pinned without old or humongous set.
        assert(!hr->is_pinned(), "Heap region %u is pinned but not old (archive) or humongous.", hr->hrm_index());
        ShouldNotReachHere();
      }
-     return false;
    }
  
    void verify_counts(HeapRegionSet* old_set, HeapRegionSet* humongous_set, HeapRegionManager* free_list) {
      guarantee(old_set->length() == _old_count, "Old set count mismatch. Expected %u, actual %u.", old_set->length(), _old_count);
      guarantee(humongous_set->length() == _humongous_count, "Hum set count mismatch. Expected %u, actual %u.", humongous_set->length(), _humongous_count);
--- 448,457 ----
*** 537,553 ****
    G1HeapVerifier* _verifier;
    G1SATBCardTableModRefBS* _ct_bs;
  public:
    G1VerifyCardTableCleanup(G1HeapVerifier* verifier, G1SATBCardTableModRefBS* ct_bs)
      : _verifier(verifier), _ct_bs(ct_bs) { }
!   virtual bool doHeapRegion(HeapRegion* r) {
      if (r->is_survivor()) {
        _verifier->verify_dirty_region(r);
      } else {
        _verifier->verify_not_dirty_region(r);
      }
-     return false;
    }
  };
  
  void G1HeapVerifier::verify_card_table_cleanup() {
    if (G1VerifyCTCleanup || VerifyAfterGC) {
--- 536,551 ----
    G1HeapVerifier* _verifier;
    G1SATBCardTableModRefBS* _ct_bs;
  public:
    G1VerifyCardTableCleanup(G1HeapVerifier* verifier, G1SATBCardTableModRefBS* ct_bs)
      : _verifier(verifier), _ct_bs(ct_bs) { }
!   virtual void doHeapRegion(HeapRegion* r) {
      if (r->is_survivor()) {
        _verifier->verify_dirty_region(r);
      } else {
        _verifier->verify_not_dirty_region(r);
      }
    }
  };
  
  void G1HeapVerifier::verify_card_table_cleanup() {
    if (G1VerifyCTCleanup || VerifyAfterGC) {
*** 646,661 ****
    G1VerifyBitmapClosure(const char* caller, G1HeapVerifier* verifier) :
      _caller(caller), _verifier(verifier), _failures(false) { }
  
    bool failures() { return _failures; }
  
!   virtual bool doHeapRegion(HeapRegion* hr) {
      bool result = _verifier->verify_bitmaps(_caller, hr);
      if (!result) {
        _failures = true;
      }
-     return false;
    }
  };
  
  void G1HeapVerifier::check_bitmaps(const char* caller) {
    if (!G1VerifyBitmaps) return;
--- 644,658 ----
    G1VerifyBitmapClosure(const char* caller, G1HeapVerifier* verifier) :
      _caller(caller), _verifier(verifier), _failures(false) { }
  
    bool failures() { return _failures; }
  
!   virtual void doHeapRegion(HeapRegion* hr) {
      bool result = _verifier->verify_bitmaps(_caller, hr);
      if (!result) {
        _failures = true;
      }
    }
  };
  
  void G1HeapVerifier::check_bitmaps(const char* caller) {
    if (!G1VerifyBitmaps) return;
*** 663,679 ****
    G1VerifyBitmapClosure cl(caller, this);
    _g1h->heap_region_iterate(&cl);
    guarantee(!cl.failures(), "bitmap verification");
  }
  
! class G1CheckCSetFastTableClosure : public HeapRegionClosure {
   private:
    bool _failures;
   public:
!   G1CheckCSetFastTableClosure() : HeapRegionClosure(), _failures(false) { }
  
!   virtual bool doHeapRegion(HeapRegion* hr) {
      uint i = hr->hrm_index();
      InCSetState cset_state = (InCSetState) G1CollectedHeap::heap()->_in_cset_fast_test.get_by_index(i);
      if (hr->is_humongous()) {
        if (hr->in_collection_set()) {
          log_error(gc, verify)("## humongous region %u in CSet", i);
--- 660,676 ----
    G1VerifyBitmapClosure cl(caller, this);
    _g1h->heap_region_iterate(&cl);
    guarantee(!cl.failures(), "bitmap verification");
  }
  
! class G1CheckCSetFastTableClosure : public AbortableHeapRegionClosure {
   private:
    bool _failures;
   public:
!   G1CheckCSetFastTableClosure() : AbortableHeapRegionClosure(), _failures(false) { }
  
!   virtual bool doHeapRegionAbortable(HeapRegion* hr) {
      uint i = hr->hrm_index();
      InCSetState cset_state = (InCSetState) G1CollectedHeap::heap()->_in_cset_fast_test.get_by_index(i);
      if (hr->is_humongous()) {
        if (hr->in_collection_set()) {
          log_error(gc, verify)("## humongous region %u in CSet", i);