src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

*** 6843,6853 ****
            // A non-array may have been imprecisely marked; we need
            // to scan object in its entirety.
            size = CompactibleFreeListSpace::adjustObjectSize(
                     p->oop_iterate(_scanningClosure));
          }
!         #ifdef DEBUG
            size_t direct_size =
              CompactibleFreeListSpace::adjustObjectSize(p->size());
            assert(size == direct_size, "Inconsistency in size");
            assert(size >= 3, "Necessary for Printezis marks to work");
            if (!_bitMap->isMarked(addr+1)) {
--- 6843,6853 ----
            // A non-array may have been imprecisely marked; we need
            // to scan object in its entirety.
            size = CompactibleFreeListSpace::adjustObjectSize(
                     p->oop_iterate(_scanningClosure));
          }
!         #ifdef ASSERT
            size_t direct_size =
              CompactibleFreeListSpace::adjustObjectSize(p->size());
            assert(size == direct_size, "Inconsistency in size");
            assert(size >= 3, "Necessary for Printezis marks to work");
            if (!_bitMap->isMarked(addr+1)) {
*** 6855,6865 ****
            } else {
              _bitMap->verifyNoOneBitsInRange(addr+2, addr+size-1);
              assert(_bitMap->isMarked(addr+size-1),
                     "inconsistent Printezis mark");
            }
!         #endif // DEBUG
      } else {
        // an unitialized object
        assert(_bitMap->isMarked(addr+1), "missing Printezis mark?");
        HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
        size = pointer_delta(nextOneAddr + 1, addr);
--- 6855,6865 ----
            } else {
              _bitMap->verifyNoOneBitsInRange(addr+2, addr+size-1);
              assert(_bitMap->isMarked(addr+size-1),
                     "inconsistent Printezis mark");
            }
!         #endif // ASSERT
      } else {
        // an unitialized object
        assert(_bitMap->isMarked(addr+1), "missing Printezis mark?");
        HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
        size = pointer_delta(nextOneAddr + 1, addr);
*** 6997,7014 ****
    // Ignore mark word because we are running concurrent with mutators
    assert(p->is_oop_or_null(true), "expected an oop or null");
    HeapWord* addr = (HeapWord*)p;
    assert(_span.contains(addr), "we are scanning the CMS generation");
    bool is_obj_array = false;
!   #ifdef DEBUG
      if (!_parallel) {
        assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)");
        assert(_collector->overflow_list_is_empty(),
               "overflow list should be empty");
  
      }
!   #endif // DEBUG
    if (_bit_map->isMarked(addr)) {
      // Obj arrays are precisely marked, non-arrays are not;
      // so we scan objArrays precisely and non-arrays in their
      // entirety.
      if (p->is_objArray()) {
--- 6997,7014 ----
    // Ignore mark word because we are running concurrent with mutators
    assert(p->is_oop_or_null(true), "expected an oop or null");
    HeapWord* addr = (HeapWord*)p;
    assert(_span.contains(addr), "we are scanning the CMS generation");
    bool is_obj_array = false;
!   #ifdef ASSERT
      if (!_parallel) {
        assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)");
        assert(_collector->overflow_list_is_empty(),
               "overflow list should be empty");
  
      }
!   #endif // ASSERT
    if (_bit_map->isMarked(addr)) {
      // Obj arrays are precisely marked, non-arrays are not;
      // so we scan objArrays precisely and non-arrays in their
      // entirety.
      if (p->is_objArray()) {
*** 7024,7041 ****
        } else {
          p->oop_iterate(_scan_closure);
        }
      }
    }
!   #ifdef DEBUG
      if (!_parallel) {
        assert(_mark_stack->isEmpty(), "post-condition (eager drainage)");
        assert(_collector->overflow_list_is_empty(),
               "overflow list should be empty");
  
      }
!   #endif // DEBUG
    return is_obj_array;
  }
  
  MarkFromRootsClosure::MarkFromRootsClosure(CMSCollector* collector,
                          MemRegion span,
--- 7024,7041 ----
        } else {
          p->oop_iterate(_scan_closure);
        }
      }
    }
!   #ifdef ASSERT
      if (!_parallel) {
        assert(_mark_stack->isEmpty(), "post-condition (eager drainage)");
        assert(_collector->overflow_list_is_empty(),
               "overflow list should be empty");
  
      }
!   #endif // ASSERT
    return is_obj_array;
  }
  
  MarkFromRootsClosure::MarkFromRootsClosure(CMSCollector* collector,
                          MemRegion span,
*** 8242,8252 ****
      HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
      size = pointer_delta(nextOneAddr + 1, addr);
      assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
             "alignment problem");
  
! #ifdef DEBUG
        if (oop(addr)->klass_or_null() != NULL) {
          // Ignore mark word because we are running concurrent with mutators
          assert(oop(addr)->is_oop(true), "live block should be an oop");
          assert(size ==
                 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()),
--- 8242,8252 ----
      HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
      size = pointer_delta(nextOneAddr + 1, addr);
      assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
             "alignment problem");
  
! #ifdef ASSERT
        if (oop(addr)->klass_or_null() != NULL) {
          // Ignore mark word because we are running concurrent with mutators
          assert(oop(addr)->is_oop(true), "live block should be an oop");
          assert(size ==
                 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()),