src/share/vm/gc_implementation/g1/concurrentMark.hpp

*** 23,32 ****
--- 23,33 ----
   */
  
  #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP
  #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP
  
+ #include "classfile/javaClasses.hpp"
  #include "gc_implementation/g1/heapRegionSet.hpp"
  #include "gc_implementation/shared/gcId.hpp"
  #include "utilities/taskqueue.hpp"
  
  class G1CollectedHeap;
*** 84,106 ****
    inline bool iterate(BitMapClosure* cl);
  
    // Return the address corresponding to the next marked bit at or after
    // "addr", and before "limit", if "limit" is non-NULL.  If there is no
    // such bit, returns "limit" if that is non-NULL, or else "endWord()".
!   HeapWord* getNextMarkedWordAddress(HeapWord* addr,
!                                      HeapWord* limit = NULL) const;
    // Return the address corresponding to the next unmarked bit at or after
    // "addr", and before "limit", if "limit" is non-NULL.  If there is no
    // such bit, returns "limit" if that is non-NULL, or else "endWord()".
!   HeapWord* getNextUnmarkedWordAddress(HeapWord* addr,
!                                        HeapWord* limit = NULL) const;
  
    // conversion utilities
    HeapWord* offsetToHeapWord(size_t offset) const {
      return _bmStartWord + (offset << _shifter);
    }
!   size_t heapWordToOffset(HeapWord* addr) const {
      return pointer_delta(addr, _bmStartWord) >> _shifter;
    }
    int heapWordDiffToOffsetDiff(size_t diff) const;
  
    // The argument addr should be the start address of a valid object
--- 85,107 ----
    inline bool iterate(BitMapClosure* cl);
  
    // Return the address corresponding to the next marked bit at or after
    // "addr", and before "limit", if "limit" is non-NULL.  If there is no
    // such bit, returns "limit" if that is non-NULL, or else "endWord()".
!   HeapWord* getNextMarkedWordAddress(const HeapWord* addr,
!                                      const HeapWord* limit = NULL) const;
    // Return the address corresponding to the next unmarked bit at or after
    // "addr", and before "limit", if "limit" is non-NULL.  If there is no
    // such bit, returns "limit" if that is non-NULL, or else "endWord()".
!   HeapWord* getNextUnmarkedWordAddress(const HeapWord* addr,
!                                        const HeapWord* limit = NULL) const;
  
    // conversion utilities
    HeapWord* offsetToHeapWord(size_t offset) const {
      return _bmStartWord + (offset << _shifter);
    }
!   size_t heapWordToOffset(const HeapWord* addr) const {
      return pointer_delta(addr, _bmStartWord) >> _shifter;
    }
    int heapWordDiffToOffsetDiff(size_t diff) const;
  
    // The argument addr should be the start address of a valid object
*** 474,483 ****
--- 475,485 ----
    FlexibleWorkGang* _parallel_workers;
  
    ForceOverflowSettings _force_overflow_conc;
    ForceOverflowSettings _force_overflow_stw;
  
+   void weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes);
    void weakRefsWork(bool clear_all_soft_refs);
  
    void swapMarkBitMaps();
  
    // It resets the global marking data structures, as well as the