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

rev 6796 : [mq]: templateOopIterate
rev 6799 : [mq]: latestChanges

*** 25,40 ****
--- 25,158 ----
  #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
  #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
  
  #include "gc_implementation/shared/markSweep.inline.hpp"
  #include "oops/objArrayKlass.hpp"
+ #include "oops/oop.inline2.hpp"
  #include "utilities/macros.hpp"
  #if INCLUDE_ALL_GCS
  #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
  #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
  #endif // INCLUDE_ALL_GCS
  
+ #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
+ {                                   \
+   T* p         = (T*)(a)->base();   \
+   T* const end = p + (a)->length(); \
+   while (p < end) {                 \
+     do_oop;                         \
+     p++;                            \
+   }                                 \
+ }
+ 
+ #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop)      \
+   if (UseCompressedOops) {                           \
+     ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
+       a, p, do_oop)                                  \
+   } else {                                           \
+     ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop,       \
+       a, p, do_oop)                                  \
+   }
+ 
+ template <bool nv, typename OopClosureType>
+ int ObjArrayKlass::oop_oop_iterate(oop obj,
+                                      OopClosureType* closure) {
+   assert (obj->is_array(), "obj must be array");
+   objArrayOop a = objArrayOop(obj);
+   /* Get size before changing pointers. */
+   /* Don't call size() or oop_size() since that is a virtual call. */
+   int size = a->object_size();
+   if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
+     Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
+   }
+   ObjArrayKlass_OOP_ITERATE(a, p, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
+   return size;
+ }
+ 
+ #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \
+ {                                   \
+   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;             \
+   while (p < end) {                 \
+     do_oop;                         \
+     ++p;                            \
+   }                                 \
+ }
+ 
+ #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \
+   if (UseCompressedOops) {                                   \
+     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
+       a, p, low, high, do_oop)                               \
+   } else {                                                   \
+     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,       \
+       a, p, low, high, do_oop)                               \
+   }
+ 
+ template <bool nv, typename OopClosureType>
+ int ObjArrayKlass::oop_oop_iterate_m(oop obj,
+                                                   OopClosureType* closure,
+                                                   MemRegion mr) {
+   assert(obj->is_array(), "obj must be array");
+   objArrayOop a  = objArrayOop(obj);
+   /* Get size before changing pointers. */
+   /* Don't call size() or oop_size() since that is a virtual call */
+   int size = a->object_size();
+   if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
+     /* SSS: Do we need to pass down mr here? */
+     Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
+   }
+   ObjArrayKlass_BOUNDED_OOP_ITERATE(
+     a, p, mr.start(), mr.end(), (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
+   return size;
+ }
+ 
+ template <bool nv, typename OopClosureType>
+ int ObjArrayKlass::oop_oop_iterate_backwards(oop obj, OopClosureType* closure) {
+   return oop_oop_iterate<nv>(obj, closure);
+ }
+ // Like oop_oop_iterate but only iterates over a specified range and only used
+ // for objArrayOops.
+ 
+ template <bool nv, typename OopClosureType>
+ int ObjArrayKlass::oop_oop_iterate_range_t(oop obj,
+                                            OopClosureType* closure,
+                                            int start, int end) {
+   assert(obj->is_array(), "obj must be array");
+   objArrayOop a  = objArrayOop(obj);
+   /* Get size before changing pointers. */
+   /* Don't call size() or oop_size() since that is a virtual call */
+   int size = a->object_size();
+   if (UseCompressedOops) {
+     HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);
+     /* this might be wierd if end needs to be aligned on HeapWord boundary */
+     HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end);
+     MemRegion mr(low, high);
+     if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
+       /* SSS: Do we need to pass down mr here? */
+       Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
+     }
+     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop,
+       a, p, low, high, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
+   } else {
+     HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start);
+     HeapWord* high = (HeapWord*)((oop*)a->base() + end);
+     MemRegion mr(low, high);
+     if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
+       /* SSS: Do we need to pass down mr here? */
+       Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
+     }
+     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,
+       a, p, low, high, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
+   }
+   return size;
+ }
+ 
+ 
  void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
    if (UseCompressedOops) {
      objarray_follow_contents<narrowOop>(obj, index);
    } else {
      objarray_follow_contents<oop>(obj, index);