31 #include "oops/oop.inline.hpp" |
31 #include "oops/oop.inline.hpp" |
32 #include "utilities/debug.hpp" |
32 #include "utilities/debug.hpp" |
33 #include "utilities/globalDefinitions.hpp" |
33 #include "utilities/globalDefinitions.hpp" |
34 #include "utilities/macros.hpp" |
34 #include "utilities/macros.hpp" |
35 |
35 |
36 template <bool nv, typename T, class OopClosureType> |
36 template <typename T, class OopClosureType> |
37 void InstanceMirrorKlass::oop_oop_iterate_statics_specialized(oop obj, OopClosureType* closure) { |
37 void InstanceMirrorKlass::oop_oop_iterate_statics(oop obj, OopClosureType* closure) { |
38 T* p = (T*)start_of_static_fields(obj); |
38 T* p = (T*)start_of_static_fields(obj); |
39 T* const end = p + java_lang_Class::static_oop_field_count(obj); |
39 T* const end = p + java_lang_Class::static_oop_field_count(obj); |
40 |
40 |
41 for (; p < end; ++p) { |
41 for (; p < end; ++p) { |
42 Devirtualizer<nv>::do_oop(closure, p); |
42 Devirtualizer::do_oop(closure, p); |
43 } |
43 } |
44 } |
44 } |
45 |
45 |
46 template <bool nv, class OopClosureType> |
46 template <typename T, class OopClosureType> |
47 void InstanceMirrorKlass::oop_oop_iterate_statics(oop obj, OopClosureType* closure) { |
47 void InstanceMirrorKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
48 if (UseCompressedOops) { |
48 InstanceKlass::oop_oop_iterate<T>(obj, closure); |
49 oop_oop_iterate_statics_specialized<nv, narrowOop>(obj, closure); |
|
50 } else { |
|
51 oop_oop_iterate_statics_specialized<nv, oop>(obj, closure); |
|
52 } |
|
53 } |
|
54 |
49 |
55 template <bool nv, class OopClosureType> |
50 if (Devirtualizer::do_metadata(closure)) { |
56 void InstanceMirrorKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
|
57 InstanceKlass::oop_oop_iterate<nv>(obj, closure); |
|
58 |
|
59 if (Devirtualizer<nv>::do_metadata(closure)) { |
|
60 Klass* klass = java_lang_Class::as_Klass(obj); |
51 Klass* klass = java_lang_Class::as_Klass(obj); |
61 // We'll get NULL for primitive mirrors. |
52 // We'll get NULL for primitive mirrors. |
62 if (klass != NULL) { |
53 if (klass != NULL) { |
63 if (klass->is_instance_klass() && InstanceKlass::cast(klass)->is_anonymous()) { |
54 if (klass->is_instance_klass() && InstanceKlass::cast(klass)->is_anonymous()) { |
64 // An anonymous class doesn't have its own class loader, so when handling |
55 // An anonymous class doesn't have its own class loader, so when handling |
65 // the java mirror for an anonymous class we need to make sure its class |
56 // the java mirror for an anonymous class we need to make sure its class |
66 // loader data is claimed, this is done by calling do_cld explicitly. |
57 // loader data is claimed, this is done by calling do_cld explicitly. |
67 // For non-anonymous classes the call to do_cld is made when the class |
58 // For non-anonymous classes the call to do_cld is made when the class |
68 // loader itself is handled. |
59 // loader itself is handled. |
69 Devirtualizer<nv>::do_cld(closure, klass->class_loader_data()); |
60 Devirtualizer::do_cld(closure, klass->class_loader_data()); |
70 } else { |
61 } else { |
71 Devirtualizer<nv>::do_klass(closure, klass); |
62 Devirtualizer::do_klass(closure, klass); |
72 } |
63 } |
73 } else { |
64 } else { |
74 // We would like to assert here (as below) that if klass has been NULL, then |
65 // We would like to assert here (as below) that if klass has been NULL, then |
75 // this has been a mirror for a primitive type that we do not need to follow |
66 // this has been a mirror for a primitive type that we do not need to follow |
76 // as they are always strong roots. |
67 // as they are always strong roots. |
81 // and kept alive during remark. |
72 // and kept alive during remark. |
82 // assert(java_lang_Class::is_primitive(obj), "Sanity check"); |
73 // assert(java_lang_Class::is_primitive(obj), "Sanity check"); |
83 } |
74 } |
84 } |
75 } |
85 |
76 |
86 oop_oop_iterate_statics<nv>(obj, closure); |
77 oop_oop_iterate_statics<T>(obj, closure); |
87 } |
78 } |
88 |
79 |
89 #if INCLUDE_OOP_OOP_ITERATE_BACKWARDS |
80 template <typename T, class OopClosureType> |
90 template <bool nv, class OopClosureType> |
|
91 void InstanceMirrorKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { |
81 void InstanceMirrorKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { |
92 InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); |
82 InstanceKlass::oop_oop_iterate_reverse<T>(obj, closure); |
93 |
83 |
94 InstanceMirrorKlass::oop_oop_iterate_statics<nv>(obj, closure); |
84 InstanceMirrorKlass::oop_oop_iterate_statics<T>(obj, closure); |
95 } |
85 } |
96 #endif // INCLUDE_OOP_OOP_ITERATE_BACKWARDS |
|
97 |
86 |
98 template <bool nv, typename T, class OopClosureType> |
87 template <typename T, class OopClosureType> |
99 void InstanceMirrorKlass::oop_oop_iterate_statics_specialized_bounded(oop obj, |
88 void InstanceMirrorKlass::oop_oop_iterate_statics_bounded(oop obj, |
100 OopClosureType* closure, |
89 OopClosureType* closure, |
101 MemRegion mr) { |
90 MemRegion mr) { |
102 T* p = (T*)start_of_static_fields(obj); |
91 T* p = (T*)start_of_static_fields(obj); |
103 T* end = p + java_lang_Class::static_oop_field_count(obj); |
92 T* end = p + java_lang_Class::static_oop_field_count(obj); |
104 |
93 |
105 T* const l = (T*)mr.start(); |
94 T* const l = (T*)mr.start(); |
106 T* const h = (T*)mr.end(); |
95 T* const h = (T*)mr.end(); |
114 if (end > h) { |
103 if (end > h) { |
115 end = h; |
104 end = h; |
116 } |
105 } |
117 |
106 |
118 for (;p < end; ++p) { |
107 for (;p < end; ++p) { |
119 Devirtualizer<nv>::do_oop(closure, p); |
108 Devirtualizer::do_oop(closure, p); |
120 } |
109 } |
121 } |
110 } |
122 |
111 |
123 template <bool nv, class OopClosureType> |
112 template <typename T, class OopClosureType> |
124 void InstanceMirrorKlass::oop_oop_iterate_statics_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
113 void InstanceMirrorKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
125 if (UseCompressedOops) { |
114 InstanceKlass::oop_oop_iterate_bounded<T>(obj, closure, mr); |
126 oop_oop_iterate_statics_specialized_bounded<nv, narrowOop>(obj, closure, mr); |
|
127 } else { |
|
128 oop_oop_iterate_statics_specialized_bounded<nv, oop>(obj, closure, mr); |
|
129 } |
|
130 } |
|
131 |
115 |
132 template <bool nv, class OopClosureType> |
116 if (Devirtualizer::do_metadata(closure)) { |
133 void InstanceMirrorKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
|
134 InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); |
|
135 |
|
136 if (Devirtualizer<nv>::do_metadata(closure)) { |
|
137 if (mr.contains(obj)) { |
117 if (mr.contains(obj)) { |
138 Klass* klass = java_lang_Class::as_Klass(obj); |
118 Klass* klass = java_lang_Class::as_Klass(obj); |
139 // We'll get NULL for primitive mirrors. |
119 // We'll get NULL for primitive mirrors. |
140 if (klass != NULL) { |
120 if (klass != NULL) { |
141 Devirtualizer<nv>::do_klass(closure, klass); |
121 Devirtualizer::do_klass(closure, klass); |
142 } |
122 } |
143 } |
123 } |
144 } |
124 } |
145 |
125 |
146 oop_oop_iterate_statics_bounded<nv>(obj, closure, mr); |
126 oop_oop_iterate_statics_bounded<T>(obj, closure, mr); |
147 } |
127 } |
148 |
128 |
149 #define ALL_INSTANCE_MIRROR_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
|
150 OOP_OOP_ITERATE_DEFN( InstanceMirrorKlass, OopClosureType, nv_suffix) \ |
|
151 OOP_OOP_ITERATE_DEFN_BOUNDED( InstanceMirrorKlass, OopClosureType, nv_suffix) \ |
|
152 OOP_OOP_ITERATE_DEFN_BACKWARDS(InstanceMirrorKlass, OopClosureType, nv_suffix) |
|
153 |
|
154 #endif // SHARE_VM_OOPS_INSTANCEMIRRORKLASS_INLINE_HPP |
129 #endif // SHARE_VM_OOPS_INSTANCEMIRRORKLASS_INLINE_HPP |