35 #include "oops/oop.inline.hpp" |
35 #include "oops/oop.inline.hpp" |
36 #include "utilities/debug.hpp" |
36 #include "utilities/debug.hpp" |
37 #include "utilities/globalDefinitions.hpp" |
37 #include "utilities/globalDefinitions.hpp" |
38 #include "utilities/macros.hpp" |
38 #include "utilities/macros.hpp" |
39 |
39 |
40 template <bool nv, typename T, class OopClosureType, class Contains> |
40 template <typename T, class OopClosureType, class Contains> |
41 void InstanceRefKlass::do_referent(oop obj, OopClosureType* closure, Contains& contains) { |
41 void InstanceRefKlass::do_referent(oop obj, OopClosureType* closure, Contains& contains) { |
42 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr_raw(obj); |
42 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr_raw(obj); |
43 if (contains(referent_addr)) { |
43 if (contains(referent_addr)) { |
44 Devirtualizer<nv>::do_oop(closure, referent_addr); |
44 Devirtualizer::do_oop(closure, referent_addr); |
45 } |
45 } |
46 } |
46 } |
47 |
47 |
48 template <bool nv, typename T, class OopClosureType, class Contains> |
48 template <typename T, class OopClosureType, class Contains> |
49 void InstanceRefKlass::do_discovered(oop obj, OopClosureType* closure, Contains& contains) { |
49 void InstanceRefKlass::do_discovered(oop obj, OopClosureType* closure, Contains& contains) { |
50 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj); |
50 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj); |
51 if (contains(discovered_addr)) { |
51 if (contains(discovered_addr)) { |
52 Devirtualizer<nv>::do_oop(closure, discovered_addr); |
52 Devirtualizer::do_oop(closure, discovered_addr); |
53 } |
53 } |
54 } |
54 } |
55 |
55 |
56 static inline oop load_referent(oop obj, ReferenceType type) { |
56 static inline oop load_referent(oop obj, ReferenceType type) { |
57 if (type == REF_PHANTOM) { |
57 if (type == REF_PHANTOM) { |
74 } |
74 } |
75 } |
75 } |
76 return false; |
76 return false; |
77 } |
77 } |
78 |
78 |
79 template <bool nv, typename T, class OopClosureType, class Contains> |
79 template <typename T, class OopClosureType, class Contains> |
80 void InstanceRefKlass::oop_oop_iterate_discovery(oop obj, ReferenceType type, OopClosureType* closure, Contains& contains) { |
80 void InstanceRefKlass::oop_oop_iterate_discovery(oop obj, ReferenceType type, OopClosureType* closure, Contains& contains) { |
81 // Try to discover reference and return if it succeeds. |
81 // Try to discover reference and return if it succeeds. |
82 if (try_discover<T>(obj, type, closure)) { |
82 if (try_discover<T>(obj, type, closure)) { |
83 return; |
83 return; |
84 } |
84 } |
85 |
85 |
86 // Treat referent and discovered as normal oops. |
86 // Treat referent and discovered as normal oops. |
87 do_referent<nv, T>(obj, closure, contains); |
87 do_referent<T>(obj, closure, contains); |
88 do_discovered<nv, T>(obj, closure, contains); |
88 do_discovered<T>(obj, closure, contains); |
89 } |
89 } |
90 |
90 |
91 template <bool nv, typename T, class OopClosureType, class Contains> |
91 template <typename T, class OopClosureType, class Contains> |
92 void InstanceRefKlass::oop_oop_iterate_fields(oop obj, OopClosureType* closure, Contains& contains) { |
92 void InstanceRefKlass::oop_oop_iterate_fields(oop obj, OopClosureType* closure, Contains& contains) { |
93 do_referent<nv, T>(obj, closure, contains); |
93 do_referent<T>(obj, closure, contains); |
94 do_discovered<nv, T>(obj, closure, contains); |
94 do_discovered<T>(obj, closure, contains); |
95 } |
95 } |
96 |
96 |
97 template <bool nv, typename T, class OopClosureType, class Contains> |
97 template <typename T, class OopClosureType, class Contains> |
98 void InstanceRefKlass::oop_oop_iterate_discovered_and_discovery(oop obj, ReferenceType type, OopClosureType* closure, Contains& contains) { |
98 void InstanceRefKlass::oop_oop_iterate_discovered_and_discovery(oop obj, ReferenceType type, OopClosureType* closure, Contains& contains) { |
99 // Explicitly apply closure to the discovered field. |
99 // Explicitly apply closure to the discovered field. |
100 do_discovered<nv, T>(obj, closure, contains); |
100 do_discovered<T>(obj, closure, contains); |
101 // Then do normal reference processing with discovery. |
101 // Then do normal reference processing with discovery. |
102 oop_oop_iterate_discovery<nv, T>(obj, type, closure, contains); |
102 oop_oop_iterate_discovery<T>(obj, type, closure, contains); |
103 } |
103 } |
104 |
104 |
105 template <bool nv, typename T, class OopClosureType, class Contains> |
105 template <typename T, class OopClosureType, class Contains> |
106 void InstanceRefKlass::oop_oop_iterate_ref_processing_specialized(oop obj, OopClosureType* closure, Contains& contains) { |
106 void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure, Contains& contains) { |
107 switch (closure->reference_iteration_mode()) { |
107 switch (closure->reference_iteration_mode()) { |
108 case ExtendedOopClosure::DO_DISCOVERY: |
108 case OopIterateClosure::DO_DISCOVERY: |
109 trace_reference_gc<T>("do_discovery", obj); |
109 trace_reference_gc<T>("do_discovery", obj); |
110 oop_oop_iterate_discovery<nv, T>(obj, reference_type(), closure, contains); |
110 oop_oop_iterate_discovery<T>(obj, reference_type(), closure, contains); |
111 break; |
111 break; |
112 case ExtendedOopClosure::DO_DISCOVERED_AND_DISCOVERY: |
112 case OopIterateClosure::DO_DISCOVERED_AND_DISCOVERY: |
113 trace_reference_gc<T>("do_discovered_and_discovery", obj); |
113 trace_reference_gc<T>("do_discovered_and_discovery", obj); |
114 oop_oop_iterate_discovered_and_discovery<nv, T>(obj, reference_type(), closure, contains); |
114 oop_oop_iterate_discovered_and_discovery<T>(obj, reference_type(), closure, contains); |
115 break; |
115 break; |
116 case ExtendedOopClosure::DO_FIELDS: |
116 case OopIterateClosure::DO_FIELDS: |
117 trace_reference_gc<T>("do_fields", obj); |
117 trace_reference_gc<T>("do_fields", obj); |
118 oop_oop_iterate_fields<nv, T>(obj, closure, contains); |
118 oop_oop_iterate_fields<T>(obj, closure, contains); |
119 break; |
119 break; |
120 default: |
120 default: |
121 ShouldNotReachHere(); |
121 ShouldNotReachHere(); |
122 } |
122 } |
123 } |
123 } |
125 class AlwaysContains { |
125 class AlwaysContains { |
126 public: |
126 public: |
127 template <typename T> bool operator()(T* p) const { return true; } |
127 template <typename T> bool operator()(T* p) const { return true; } |
128 }; |
128 }; |
129 |
129 |
130 template <bool nv, class OopClosureType> |
130 template <typename T, class OopClosureType> |
131 void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure) { |
131 void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure) { |
132 AlwaysContains always_contains; |
132 AlwaysContains always_contains; |
133 if (UseCompressedOops) { |
133 oop_oop_iterate_ref_processing<T>(obj, closure, always_contains); |
134 oop_oop_iterate_ref_processing_specialized<nv, narrowOop>(obj, closure, always_contains); |
|
135 } else { |
|
136 oop_oop_iterate_ref_processing_specialized<nv, oop>(obj, closure, always_contains); |
|
137 } |
|
138 } |
134 } |
139 |
135 |
140 class MrContains { |
136 class MrContains { |
141 const MemRegion _mr; |
137 const MemRegion _mr; |
142 public: |
138 public: |
143 MrContains(MemRegion mr) : _mr(mr) {} |
139 MrContains(MemRegion mr) : _mr(mr) {} |
144 template <typename T> bool operator()(T* p) const { return _mr.contains(p); } |
140 template <typename T> bool operator()(T* p) const { return _mr.contains(p); } |
145 }; |
141 }; |
146 |
142 |
147 template <bool nv, class OopClosureType> |
143 template <typename T, class OopClosureType> |
148 void InstanceRefKlass::oop_oop_iterate_ref_processing_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
144 void InstanceRefKlass::oop_oop_iterate_ref_processing_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
149 const MrContains contains(mr); |
145 const MrContains contains(mr); |
150 if (UseCompressedOops) { |
146 oop_oop_iterate_ref_processing<T>(obj, closure, contains); |
151 oop_oop_iterate_ref_processing_specialized<nv, narrowOop>(obj, closure, contains); |
|
152 } else { |
|
153 oop_oop_iterate_ref_processing_specialized<nv, oop>(obj, closure, contains); |
|
154 } |
|
155 } |
147 } |
156 |
148 |
157 template <bool nv, class OopClosureType> |
149 template <typename T, class OopClosureType> |
158 void InstanceRefKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
150 void InstanceRefKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { |
159 InstanceKlass::oop_oop_iterate<nv>(obj, closure); |
151 InstanceKlass::oop_oop_iterate<T>(obj, closure); |
160 |
152 |
161 oop_oop_iterate_ref_processing<nv>(obj, closure); |
153 oop_oop_iterate_ref_processing<T>(obj, closure); |
162 } |
154 } |
163 |
155 |
164 #if INCLUDE_OOP_OOP_ITERATE_BACKWARDS |
156 template <typename T, class OopClosureType> |
165 template <bool nv, class OopClosureType> |
|
166 void InstanceRefKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { |
157 void InstanceRefKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { |
167 InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); |
158 InstanceKlass::oop_oop_iterate_reverse<T>(obj, closure); |
168 |
159 |
169 oop_oop_iterate_ref_processing<nv>(obj, closure); |
160 oop_oop_iterate_ref_processing<T>(obj, closure); |
170 } |
161 } |
171 #endif // INCLUDE_OOP_OOP_ITERATE_BACKWARDS |
|
172 |
162 |
|
163 template <typename T, class OopClosureType> |
|
164 void InstanceRefKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
|
165 InstanceKlass::oop_oop_iterate_bounded<T>(obj, closure, mr); |
173 |
166 |
174 template <bool nv, class OopClosureType> |
167 oop_oop_iterate_ref_processing_bounded<T>(obj, closure, mr); |
175 void InstanceRefKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { |
|
176 InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); |
|
177 |
|
178 oop_oop_iterate_ref_processing_bounded<nv>(obj, closure, mr); |
|
179 } |
168 } |
180 |
169 |
181 #ifdef ASSERT |
170 #ifdef ASSERT |
182 template <typename T> |
171 template <typename T> |
183 void InstanceRefKlass::trace_reference_gc(const char *s, oop obj) { |
172 void InstanceRefKlass::trace_reference_gc(const char *s, oop obj) { |