10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
26 #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
27
28 #include "gc_implementation/shared/markSweep.inline.hpp"
29 #include "oops/objArrayKlass.hpp"
30 #include "utilities/macros.hpp"
31 #if INCLUDE_ALL_GCS
32 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
33 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
34 #endif // INCLUDE_ALL_GCS
35
36 void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
37 if (UseCompressedOops) {
38 objarray_follow_contents<narrowOop>(obj, index);
39 } else {
40 objarray_follow_contents<oop>(obj, index);
41 }
42 }
43
44 template <class T>
45 void ObjArrayKlass::objarray_follow_contents(oop obj, int index) {
46 objArrayOop a = objArrayOop(obj);
47 const size_t len = size_t(a->length());
48 const size_t beg_index = size_t(index);
49 assert(beg_index < len || len == 0, "index too large");
50
51 const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
52 const size_t end_index = beg_index + stride;
53 T* const base = (T*)a->base();
54 T* const beg = base + beg_index;
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
26 #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP
27
28 #include "gc_implementation/shared/markSweep.inline.hpp"
29 #include "oops/objArrayKlass.hpp"
30 #include "oops/oop.inline2.hpp"
31 #include "utilities/macros.hpp"
32 #if INCLUDE_ALL_GCS
33 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
34 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
35 #endif // INCLUDE_ALL_GCS
36
37 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
38 { \
39 T* p = (T*)(a)->base(); \
40 T* const end = p + (a)->length(); \
41 while (p < end) { \
42 do_oop; \
43 p++; \
44 } \
45 }
46
47 #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop) \
48 if (UseCompressedOops) { \
49 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
50 a, p, do_oop) \
51 } else { \
52 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \
53 a, p, do_oop) \
54 }
55
56 template <bool nv, typename OopClosureType>
57 int ObjArrayKlass::oop_oop_iterate(oop obj,
58 OopClosureType* closure) {
59 assert (obj->is_array(), "obj must be array");
60 objArrayOop a = objArrayOop(obj);
61 /* Get size before changing pointers. */
62 /* Don't call size() or oop_size() since that is a virtual call. */
63 int size = a->object_size();
64 if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
65 Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
66 }
67 ObjArrayKlass_OOP_ITERATE(a, p, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
68 return size;
69 }
70
71 #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \
72 { \
73 T* const l = (T*)(low); \
74 T* const h = (T*)(high); \
75 T* p = (T*)(a)->base(); \
76 T* end = p + (a)->length(); \
77 if (p < l) p = l; \
78 if (end > h) end = h; \
79 while (p < end) { \
80 do_oop; \
81 ++p; \
82 } \
83 }
84
85 #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \
86 if (UseCompressedOops) { \
87 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
88 a, p, low, high, do_oop) \
89 } else { \
90 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
91 a, p, low, high, do_oop) \
92 }
93
94 template <bool nv, typename OopClosureType>
95 int ObjArrayKlass::oop_oop_iterate_m(oop obj,
96 OopClosureType* closure,
97 MemRegion mr) {
98 assert(obj->is_array(), "obj must be array");
99 objArrayOop a = objArrayOop(obj);
100 /* Get size before changing pointers. */
101 /* Don't call size() or oop_size() since that is a virtual call */
102 int size = a->object_size();
103 if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
104 /* SSS: Do we need to pass down mr here? */
105 Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
106 }
107 ObjArrayKlass_BOUNDED_OOP_ITERATE(
108 a, p, mr.start(), mr.end(), (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
109 return size;
110 }
111
112 template <bool nv, typename OopClosureType>
113 int ObjArrayKlass::oop_oop_iterate_backwards(oop obj, OopClosureType* closure) {
114 return oop_oop_iterate<nv>(obj, closure);
115 }
116 // Like oop_oop_iterate but only iterates over a specified range and only used
117 // for objArrayOops.
118
119 template <bool nv, typename OopClosureType>
120 int ObjArrayKlass::oop_oop_iterate_range_t(oop obj,
121 OopClosureType* closure,
122 int start, int end) {
123 assert(obj->is_array(), "obj must be array");
124 objArrayOop a = objArrayOop(obj);
125 /* Get size before changing pointers. */
126 /* Don't call size() or oop_size() since that is a virtual call */
127 int size = a->object_size();
128 if (UseCompressedOops) {
129 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);
130 /* this might be wierd if end needs to be aligned on HeapWord boundary */
131 HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end);
132 MemRegion mr(low, high);
133 if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
134 /* SSS: Do we need to pass down mr here? */
135 Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
136 }
137 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop,
138 a, p, low, high, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
139 } else {
140 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start);
141 HeapWord* high = (HeapWord*)((oop*)a->base() + end);
142 MemRegion mr(low, high);
143 if (Devirtualizer<nv, OopClosureType>::do_metadata(closure)) {
144 /* SSS: Do we need to pass down mr here? */
145 Devirtualizer<nv, OopClosureType>::do_klass(closure, obj->klass());
146 }
147 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,
148 a, p, low, high, (Devirtualizer<nv, OopClosureType>::do_oop(closure, p)))
149 }
150 return size;
151 }
152
153
154 void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
155 if (UseCompressedOops) {
156 objarray_follow_contents<narrowOop>(obj, index);
157 } else {
158 objarray_follow_contents<oop>(obj, index);
159 }
160 }
161
162 template <class T>
163 void ObjArrayKlass::objarray_follow_contents(oop obj, int index) {
164 objArrayOop a = objArrayOop(obj);
165 const size_t len = size_t(a->length());
166 const size_t beg_index = size_t(index);
167 assert(beg_index < len || len == 0, "index too large");
168
169 const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
170 const size_t end_index = beg_index + stride;
171 T* const base = (T*)a->base();
172 T* const beg = base + beg_index;
|