src/hotspot/share/oops/objArrayKlass.inline.hpp

@@ -31,79 +31,46 @@
  #include "oops/arrayKlass.hpp"
  #include "oops/arrayOop.hpp"
  #include "oops/klass.hpp"
  #include "oops/objArrayOop.inline.hpp"
  #include "oops/oop.inline.hpp"
+ #include "runtime/atomicAccess.hpp"
  #include "utilities/devirtualizer.inline.hpp"
  #include "utilities/macros.hpp"
  
- template <typename T, class OopClosureType>
- void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) {
-   oop_oop_iterate_elements_range<T>(a, closure, 0, a->length());
+ 
+ inline ObjArrayKlass* ObjArrayKlass::next_refined_array_klass_acquire() const {
+   return AtomicAccess::load_acquire(&_next_refined_array_klass);
  }
  
- // Like oop_oop_iterate but only iterates over a specified range and only used
- // for objArrayOops.
- template <typename T, class OopClosureType>
- void ObjArrayKlass::oop_oop_iterate_elements_range(objArrayOop a, OopClosureType* closure, int start, int end) {
-   T* base        = (T*)a->base();
-   T* p           = base + start;
-   T* const end_p = base + end;
+ inline void ObjArrayKlass::release_set_next_refined_klass(ObjArrayKlass* k) {
+   AtomicAccess::release_store(&_next_refined_array_klass, k);
+ }
  
-   for (;p < end_p; ++p) {
-     Devirtualizer::do_oop(closure, p);
-   }
+ template <typename T, class OopClosureType>
+ void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) {
+   ShouldNotReachHere();
  }
  
  template <typename T, class OopClosureType>
  void ObjArrayKlass::oop_oop_iterate_elements_bounded(
      objArrayOop a, OopClosureType* closure, void* low, void* high) {
+   ShouldNotReachHere();
  
-   T* const l = (T*)low;
-   T* const h = (T*)high;
- 
-   T* p   = (T*)a->base();
-   T* end = p + a->length();
- 
-   if (p < l) {
-     p = l;
-   }
-   if (end > h) {
-     end = h;
-   }
- 
-   for (;p < end; ++p) {
-     Devirtualizer::do_oop(closure, p);
-   }
  }
  
  template <typename T, typename OopClosureType>
  void ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {
-   assert(obj->is_array(), "obj must be array");
-   objArrayOop a = objArrayOop(obj);
- 
-   if (Devirtualizer::do_metadata(closure)) {
-     Devirtualizer::do_klass(closure, obj->klass());
-   }
- 
-   oop_oop_iterate_elements<T>(a, closure);
+   ShouldNotReachHere();
  }
  
  template <typename T, typename OopClosureType>
  void ObjArrayKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {
-   // No reverse implementation ATM.
-   oop_oop_iterate<T>(obj, closure);
+   ShouldNotReachHere();
  }
  
  template <typename T, typename OopClosureType>
  void ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {
-   assert(obj->is_array(), "obj must be array");
-   objArrayOop a  = objArrayOop(obj);
- 
-   if (Devirtualizer::do_metadata(closure)) {
-     Devirtualizer::do_klass(closure, a->klass());
-   }
- 
-   oop_oop_iterate_elements_bounded<T>(a, closure, mr.start(), mr.end());
+   ShouldNotReachHere();
  }
  
  #endif // SHARE_OOPS_OBJARRAYKLASS_INLINE_HPP