24 |
24 |
25 #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |
25 #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |
26 #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |
26 #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |
27 |
27 |
28 #include "memory/memRegion.hpp" |
28 #include "memory/memRegion.hpp" |
29 #include "memory/iterator.inline.hpp" |
29 #include "memory/iterator.hpp" |
30 #include "oops/arrayOop.inline.hpp" |
30 #include "oops/arrayOop.inline.hpp" |
31 #include "oops/arrayKlass.hpp" |
31 #include "oops/arrayKlass.hpp" |
32 #include "oops/klass.hpp" |
32 #include "oops/klass.hpp" |
33 #include "oops/objArrayKlass.hpp" |
33 #include "oops/objArrayKlass.hpp" |
34 #include "oops/objArrayOop.inline.hpp" |
34 #include "oops/objArrayOop.inline.hpp" |
35 #include "oops/oop.inline.hpp" |
35 #include "oops/oop.inline.hpp" |
36 #include "utilities/macros.hpp" |
36 #include "utilities/macros.hpp" |
37 |
37 |
38 template <bool nv, typename T, class OopClosureType> |
38 template <typename T, class OopClosureType> |
39 void ObjArrayKlass::oop_oop_iterate_elements_specialized(objArrayOop a, OopClosureType* closure) { |
39 void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) { |
40 T* p = (T*)a->base_raw(); |
40 T* p = (T*)a->base_raw(); |
41 T* const end = p + a->length(); |
41 T* const end = p + a->length(); |
42 |
42 |
43 for (;p < end; p++) { |
43 for (;p < end; p++) { |
44 Devirtualizer<nv>::do_oop(closure, p); |
44 Devirtualizer::do_oop(closure, p); |
45 } |
45 } |
46 } |
46 } |
47 |
47 |
48 template <bool nv, typename T, class OopClosureType> |
48 template <typename T, class OopClosureType> |
49 void ObjArrayKlass::oop_oop_iterate_elements_specialized_bounded( |
49 void ObjArrayKlass::oop_oop_iterate_elements_bounded( |
50 objArrayOop a, OopClosureType* closure, void* low, void* high) { |
50 objArrayOop a, OopClosureType* closure, void* low, void* high) { |
51 |
51 |
52 T* const l = (T*)low; |
52 T* const l = (T*)low; |
53 T* const h = (T*)high; |
53 T* const h = (T*)high; |
54 |
54 |
61 if (end > h) { |
61 if (end > h) { |
62 end = h; |
62 end = h; |
63 } |
63 } |
64 |
64 |
65 for (;p < end; ++p) { |
65 for (;p < end; ++p) { |
66 Devirtualizer<nv>::do_oop(closure, p); |
66 Devirtualizer::do_oop(closure, p); |
67 } |
67 } |
68 } |
68 } |
69 |
69 |
70 template <bool nv, class OopClosureType> |
70 template <typename T, typename OopClosureType> |
71 void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) { |
|
72 if (UseCompressedOops) { |
|
73 oop_oop_iterate_elements_specialized<nv, narrowOop>(a, closure); |
|
74 } else { |
|
75 oop_oop_iterate_elements_specialized<nv, oop>(a, closure); |
|
76 } |
|
77 } |
|
78 |
|
79 template <bool nv, class OopClosureType> |
|
80 void ObjArrayKlass::oop_oop_iterate_elements_bounded(objArrayOop a, OopClosureType* closure, MemRegion mr) { |
|
81 if (UseCompressedOops) { |
|
82 oop_oop_iterate_elements_specialized_bounded<nv, narrowOop>(a, closure, mr.start(), mr.end()); |
|
83 } else { |
|
84 oop_oop_iterate_elements_specialized_bounded<nv, oop>(a, closure, mr.start(), mr.end()); |
|
85 } |
|
86 } |
|
87 |
|
88 template <bool nv, typename OopClosureType> |
|
89 void ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
71 void ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
90 assert (obj->is_array(), "obj must be array"); |
72 assert (obj->is_array(), "obj must be array"); |
91 objArrayOop a = objArrayOop(obj); |
73 objArrayOop a = objArrayOop(obj); |
92 |
74 |
93 if (Devirtualizer<nv>::do_metadata(closure)) { |
75 if (Devirtualizer::do_metadata(closure)) { |
94 Devirtualizer<nv>::do_klass(closure, obj->klass()); |
76 Devirtualizer::do_klass(closure, obj->klass()); |
95 } |
77 } |
96 |
78 |
97 oop_oop_iterate_elements<nv>(a, closure); |
79 oop_oop_iterate_elements<T>(a, closure); |
98 } |
80 } |
99 |
81 |
100 template <bool nv, typename OopClosureType> |
82 template <typename T, typename OopClosureType> |
|
83 void ObjArrayKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { |
|
84 // No reverse implementation ATM. |
|
85 oop_oop_iterate<T>(obj, closure); |
|
86 } |
|
87 |
|
88 template <typename T, typename OopClosureType> |
101 void ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
89 void ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
102 assert(obj->is_array(), "obj must be array"); |
90 assert(obj->is_array(), "obj must be array"); |
103 objArrayOop a = objArrayOop(obj); |
91 objArrayOop a = objArrayOop(obj); |
104 |
92 |
105 if (Devirtualizer<nv>::do_metadata(closure)) { |
93 if (Devirtualizer::do_metadata(closure)) { |
106 Devirtualizer<nv>::do_klass(closure, a->klass()); |
94 Devirtualizer::do_klass(closure, a->klass()); |
107 } |
95 } |
108 |
96 |
109 oop_oop_iterate_elements_bounded<nv>(a, closure, mr); |
97 oop_oop_iterate_elements_bounded<T>(a, closure, mr.start(), mr.end()); |
110 } |
|
111 |
|
112 template <bool nv, typename T, class OopClosureType> |
|
113 void ObjArrayKlass::oop_oop_iterate_range_specialized(objArrayOop a, OopClosureType* closure, int start, int end) { |
|
114 T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr_raw<T>(start); |
|
115 T* high = (T*)a->base_raw() + end; |
|
116 |
|
117 oop_oop_iterate_elements_specialized_bounded<nv, T>(a, closure, low, high); |
|
118 } |
98 } |
119 |
99 |
120 // Like oop_oop_iterate but only iterates over a specified range and only used |
100 // Like oop_oop_iterate but only iterates over a specified range and only used |
121 // for objArrayOops. |
101 // for objArrayOops. |
122 template <bool nv, class OopClosureType> |
102 template <typename T, class OopClosureType> |
123 void ObjArrayKlass::oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end) { |
103 void ObjArrayKlass::oop_oop_iterate_range(objArrayOop a, OopClosureType* closure, int start, int end) { |
124 assert(obj->is_array(), "obj must be array"); |
104 T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr_raw<T>(start); |
125 objArrayOop a = objArrayOop(obj); |
105 T* high = (T*)a->base_raw() + end; |
126 |
106 |
|
107 oop_oop_iterate_elements_bounded<T>(a, closure, low, high); |
|
108 } |
|
109 |
|
110 // Placed here to resolve include cycle between objArrayKlass.inline.hpp and objArrayOop.inline.hpp |
|
111 template <typename OopClosureType> |
|
112 void objArrayOopDesc::oop_iterate_range(OopClosureType* blk, int start, int end) { |
127 if (UseCompressedOops) { |
113 if (UseCompressedOops) { |
128 oop_oop_iterate_range_specialized<nv, narrowOop>(a, closure, start, end); |
114 ((ObjArrayKlass*)klass())->oop_oop_iterate_range<narrowOop>(this, blk, start, end); |
129 } else { |
115 } else { |
130 oop_oop_iterate_range_specialized<nv, oop>(a, closure, start, end); |
116 ((ObjArrayKlass*)klass())->oop_oop_iterate_range<oop>(this, blk, start, end); |
131 } |
117 } |
132 } |
118 } |
133 |
119 |
134 #define ALL_OBJ_ARRAY_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
|
135 OOP_OOP_ITERATE_DEFN( ObjArrayKlass, OopClosureType, nv_suffix) \ |
|
136 OOP_OOP_ITERATE_DEFN_BOUNDED( ObjArrayKlass, OopClosureType, nv_suffix) \ |
|
137 OOP_OOP_ITERATE_DEFN_RANGE( ObjArrayKlass, OopClosureType, nv_suffix) \ |
|
138 OOP_OOP_ITERATE_DEFN_NO_BACKWARDS(ObjArrayKlass, OopClosureType, nv_suffix) |
|
139 |
|
140 #endif // SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |
120 #endif // SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP |