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

rev 12906 : [mq]: gc_interface

*** 24,102 ****
  
  #ifndef SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP
  #define SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP
  
  #include "gc/shared/barrierSet.hpp"
  
! // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
! // enumerate ref fields that have been modified (since the last
! // enumeration), using a card table.
! 
! class OopClosure;
! class Generation;
  
  class ModRefBarrierSet: public BarrierSet {
  public:
  
!   // Barriers only on ref writes.
!   bool has_read_ref_barrier() { return false; }
!   bool has_read_prim_barrier() { return false; }
!   bool has_write_ref_barrier() { return true; }
!   bool has_write_prim_barrier() { return false; }
! 
!   bool read_ref_needs_barrier(void* field) { return false; }
!   bool read_prim_needs_barrier(HeapWord* field, size_t bytes) { return false; }
!   bool write_prim_needs_barrier(HeapWord* field, size_t bytes,
!                                 juint val1, juint val2) { return false; }
  
!   void write_prim_field(oop obj, size_t offset, size_t bytes,
!                         juint val1, juint val2) {}
  
!   void read_ref_field(void* field) {}
!   void read_prim_field(HeapWord* field, size_t bytes) {}
  
! protected:
  
!   ModRefBarrierSet(const BarrierSet::FakeRtti& fake_rtti)
!     : BarrierSet(fake_rtti.add_tag(BarrierSet::ModRef)) { }
!   ~ModRefBarrierSet() { }
  
! public:
!   void write_prim_field(HeapWord* field, size_t bytes,
!                         juint val1, juint val2) {}
  
!   bool has_read_ref_array_opt() { return false; }
!   bool has_read_prim_array_opt() { return false; }
!   bool has_write_prim_array_opt() { return false; }
  
!   bool has_read_region_opt() { return false; }
  
  
!   // These operations should assert false unless the corresponding operation
!   // above returns true.
!   void read_ref_array(MemRegion mr) {
!     assert(false, "can't call");
!   }
!   void read_prim_array(MemRegion mr) {
!     assert(false, "can't call");
!   }
!   void write_prim_array(MemRegion mr) {
!     assert(false, "can't call");
!   }
!   void read_region(MemRegion mr) {
!     assert(false, "can't call");
    }
  
!   // Causes all refs in "mr" to be assumed to be modified.
!   virtual void invalidate(MemRegion mr) = 0;
  
!   // The caller guarantees that "mr" contains no references.  (Perhaps it's
!   // objects have been moved elsewhere.)
!   virtual void clear(MemRegion mr) = 0;
  };
  
  template<>
! struct BarrierSet::GetName<ModRefBarrierSet> {
    static const BarrierSet::Name value = BarrierSet::ModRef;
  };
  
  #endif // SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP
--- 24,122 ----
  
  #ifndef SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP
  #define SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP
  
  #include "gc/shared/barrierSet.hpp"
+ #include "memory/memRegion.hpp"
  
! class Klass;
  
  class ModRefBarrierSet: public BarrierSet {
+ protected:
+   ModRefBarrierSet(const BarrierSet::FakeRtti& fake_rtti)
+     : BarrierSet(fake_rtti.add_tag(BarrierSet::ModRef)) { }
+   ~ModRefBarrierSet() { }
+ 
+   virtual void write_ref_array_region(MemRegion mr) = 0;
+ 
+   // These methods serve the only purpose of speeding up build times by reducing
+   // included files
+   static Klass* bound_for_array(oop obj);
+   static bool is_bounded_by(oop obj, Klass* klass);
+ 
  public:
+   // Causes all refs in "mr" to be assumed to be modified.
+   virtual void invalidate(MemRegion mr) = 0;
  
!   // Operations on arrays, or general regions (e.g., for "clone") may be
!   // optimized by some barriers.
  
!   // Below length is the # array elements being written
!   virtual void write_ref_array_pre(oop* dst, int length,
!                                    bool dest_uninitialized = false) {}
!   virtual void write_ref_array_pre(narrowOop* dst, int length,
!                                    bool dest_uninitialized = false) {}
!   // Below count is the # array elements being written, starting
!   // at the address "start", which may not necessarily be HeapWord-aligned
!   inline void write_ref_array(HeapWord* start, size_t count);
  
!   // Static versions, suitable for calling from generated code;
!   // count is # array elements being written, starting with "start",
!   // which may not necessarily be HeapWord-aligned.
!   static void static_write_ref_array_pre(HeapWord* start, size_t count);
!   static void static_write_ref_array_post(HeapWord* start, size_t count);
  
!   template <DecoratorSet decorators>
!   inline void write_ref_field_pre(void* addr) {}
  
!   template <DecoratorSet decorators>
!   inline void write_ref_field_post(void *addr, oop new_value) {}
  
!   // barriers used by klass_oop_store
!   void klass_update_barrier_set_pre(Klass* klass, oop* p) {}
!   void klass_update_barrier_set(Klass* klass, oop* p, oop v);
  
!   template <DecoratorSet decorators, typename BarrierSetT>
!   class AccessBarrier: public BarrierSet::AccessBarrier<decorators> {
!     typedef BarrierSet::AccessBarrier<decorators> Basic;
  
!   public:
!     typedef Basic SuperAccessBarrier;
  
+     static void oop_store(void* addr, oop value);
  
!     static oop oop_cas(oop new_value, void* addr, oop compare_value);
! 
!     static oop oop_swap(oop new_value, void* addr);
! 
!     template <typename T>
!     static bool oop_copy(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length);
! 
!     static void clone(oop src, oop dst, size_t size);
! 
!     static inline void oop_store_at(oop base, ptrdiff_t offset, oop value) {
!       oop_store(Basic::field_addr(base, offset), value);
      }
  
!     static inline void oop_store_at(Klass* base, ptrdiff_t offset, oop value);
! 
!     static inline oop oop_swap_at(oop new_value, oop base, ptrdiff_t offset) {
!       return oop_swap(new_value, Basic::field_addr(base, offset));
!     }
  
!     static inline oop oop_cas_at(oop new_value, oop base, ptrdiff_t offset, oop compare_value) {
!       return oop_cas(new_value, Basic::field_addr(base, offset), compare_value);
!     }
!   };
  };
  
  template<>
! struct BSTypeToName<ModRefBarrierSet> {
    static const BarrierSet::Name value = BarrierSet::ModRef;
  };
  
+ template<>
+ struct BSNameToType<BarrierSet::ModRef> {
+   typedef ModRefBarrierSet type;
+ };
+ 
  #endif // SHARE_VM_GC_SHARED_MODREFBARRIERSET_HPP