src/share/vm/gc/shared/space.hpp

rev 12906 : [mq]: gc_interface

@@ -24,11 +24,11 @@
 
 #ifndef SHARE_VM_GC_SHARED_SPACE_HPP
 #define SHARE_VM_GC_SHARED_SPACE_HPP
 
 #include "gc/shared/blockOffsetTable.hpp"
-#include "gc/shared/cardTableModRefBS.hpp"
+#include "gc/shared/cardTable.hpp"
 #include "gc/shared/workgroup.hpp"
 #include "memory/allocation.hpp"
 #include "memory/iterator.hpp"
 #include "memory/memRegion.hpp"
 #include "oops/markOop.hpp"

@@ -178,11 +178,11 @@
   // Create and return a new dirty card to oop closure. Can be
   // overridden to return the appropriate type of closure
   // depending on the type of space in which the closure will
   // operate. ResourceArea allocated.
   virtual DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
-                                             CardTableModRefBS::PrecisionStyle precision,
+                                             CardTable::PrecisionStyle precision,
                                              HeapWord* boundary,
                                              bool parallel);
 
   // If "p" is in the space, returns the address of the start of the
   // "block" that contains "p".  We say "block" instead of "object" since

@@ -250,11 +250,11 @@
 
 class DirtyCardToOopClosure: public MemRegionClosureRO {
 protected:
   ExtendedOopClosure* _cl;
   Space* _sp;
-  CardTableModRefBS::PrecisionStyle _precision;
+  CardTable::PrecisionStyle _precision;
   HeapWord* _boundary;          // If non-NULL, process only non-NULL oops
                                 // pointing below boundary.
   HeapWord* _min_done;          // ObjHeadPreciseArray precision requires
                                 // a downwards traversal; this is the
                                 // lowest location already done (or,

@@ -279,11 +279,11 @@
   // or possibly more efficient walking.
   virtual void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top);
 
 public:
   DirtyCardToOopClosure(Space* sp, ExtendedOopClosure* cl,
-                        CardTableModRefBS::PrecisionStyle precision,
+                        CardTable::PrecisionStyle precision,
                         HeapWord* boundary) :
     _sp(sp), _cl(cl), _precision(precision), _boundary(boundary),
     _min_done(NULL) {
     NOT_PRODUCT(_last_bottom = NULL);
     NOT_PRODUCT(_last_explicit_min_done = NULL);

@@ -613,11 +613,11 @@
     set_concurrent_iteration_safe_limit(compaction_top());
   }
 
   // Override.
   DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
-                                     CardTableModRefBS::PrecisionStyle precision,
+                                     CardTable::PrecisionStyle precision,
                                      HeapWord* boundary,
                                      bool parallel);
 
   // Apply "blk->do_oop" to the addresses of all reference fields in objects
   // starting with the _saved_mark_word, which was noted during a generation's

@@ -688,11 +688,11 @@
                                        HeapWord* bottom, HeapWord* top,
                                        FilteringClosure* cl) = 0;
 
 public:
   FilteringDCTOC(Space* sp, ExtendedOopClosure* cl,
-                  CardTableModRefBS::PrecisionStyle precision,
+                  CardTable::PrecisionStyle precision,
                   HeapWord* boundary) :
     DirtyCardToOopClosure(sp, cl, precision, boundary) {}
 };
 
 // A dirty card to oop closure for contiguous spaces

@@ -717,11 +717,11 @@
                                        HeapWord* bottom, HeapWord* top,
                                        FilteringClosure* cl);
 
 public:
   ContiguousSpaceDCTOC(ContiguousSpace* sp, ExtendedOopClosure* cl,
-                       CardTableModRefBS::PrecisionStyle precision,
+                       CardTable::PrecisionStyle precision,
                        HeapWord* boundary) :
     FilteringDCTOC(sp, cl, precision, boundary)
   {}
 };