< prev index next >

src/hotspot/share/oops/instanceKlass.inline.hpp

8212595: Remove unused size_helper() in oop_oop_iterate* in instanceKlass.inline.hpp

112   OopMapBlock* const start_map = start_of_nonstatic_oop_maps();                                                            
113   OopMapBlock* map             = start_map + nonstatic_oop_map_count();                                                    
114 
115   while (start_map < map) {                                                                                                
116     --map;                                                                                                                 
117     oop_oop_iterate_oop_map_reverse<T>(map, obj, closure);                                                                 
118   }                                                                                                                        
119 }                                                                                                                          
120 
121 template <typename T, class OopClosureType>                                                                                
122 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_bounded(oop obj, OopClosureType* closure, MemRegion mr) {        
123   OopMapBlock* map           = start_of_nonstatic_oop_maps();                                                              
124   OopMapBlock* const end_map = map + nonstatic_oop_map_count();                                                            
125 
126   for (;map < end_map; ++map) {                                                                                            
127     oop_oop_iterate_oop_map_bounded<T>(map, obj, closure, mr);                                                             
128   }                                                                                                                        
129 }                                                                                                                          
130 
131 template <typename T, class OopClosureType>                                                                                
132 ALWAYSINLINE int InstanceKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {                                        
133   if (Devirtualizer::do_metadata(closure)) {                                                                               
134     Devirtualizer::do_klass(closure, this);                                                                                
135   }                                                                                                                        
136 
137   oop_oop_iterate_oop_maps<T>(obj, closure);                                                                               
138                                                                                                                            
139   return size_helper();                                                                                                    
140 }                                                                                                                          
141 
142 template <typename T, class OopClosureType>                                                                                
143 ALWAYSINLINE int InstanceKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {                                
144   assert(!Devirtualizer::do_metadata(closure),                                                                             
145       "Code to handle metadata is not implemented");                                                                       
146 
147   oop_oop_iterate_oop_maps_reverse<T>(obj, closure);                                                                       
148                                                                                                                            
149   return size_helper();                                                                                                    
150 }                                                                                                                          
151 
152 template <typename T, class OopClosureType>                                                                                
153 ALWAYSINLINE int InstanceKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {                  
154   if (Devirtualizer::do_metadata(closure)) {                                                                               
155     if (mr.contains(obj)) {                                                                                                
156       Devirtualizer::do_klass(closure, this);                                                                              
157     }                                                                                                                      
158   }                                                                                                                        
159 
160   oop_oop_iterate_oop_maps_bounded<T>(obj, closure, mr);                                                                   
161                                                                                                                            
162   return size_helper();                                                                                                    
163 }                                                                                                                          
164 
165 #endif // SHARE_VM_OOPS_INSTANCEKLASS_INLINE_HPP                                                                           

112   OopMapBlock* const start_map = start_of_nonstatic_oop_maps();
113   OopMapBlock* map             = start_map + nonstatic_oop_map_count();
114 
115   while (start_map < map) {
116     --map;
117     oop_oop_iterate_oop_map_reverse<T>(map, obj, closure);
118   }
119 }
120 
121 template <typename T, class OopClosureType>
122 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_bounded(oop obj, OopClosureType* closure, MemRegion mr) {
123   OopMapBlock* map           = start_of_nonstatic_oop_maps();
124   OopMapBlock* const end_map = map + nonstatic_oop_map_count();
125 
126   for (;map < end_map; ++map) {
127     oop_oop_iterate_oop_map_bounded<T>(map, obj, closure, mr);
128   }
129 }
130 
131 template <typename T, class OopClosureType>
132 ALWAYSINLINE void InstanceKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {
133   if (Devirtualizer::do_metadata(closure)) {
134     Devirtualizer::do_klass(closure, this);
135   }
136 
137   oop_oop_iterate_oop_maps<T>(obj, closure);


138 }
139 
140 template <typename T, class OopClosureType>
141 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {
142   assert(!Devirtualizer::do_metadata(closure),
143       "Code to handle metadata is not implemented");
144 
145   oop_oop_iterate_oop_maps_reverse<T>(obj, closure);


146 }
147 
148 template <typename T, class OopClosureType>
149 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {
150   if (Devirtualizer::do_metadata(closure)) {
151     if (mr.contains(obj)) {
152       Devirtualizer::do_klass(closure, this);
153     }
154   }
155 
156   oop_oop_iterate_oop_maps_bounded<T>(obj, closure, mr);


157 }
158 
159 #endif // SHARE_VM_OOPS_INSTANCEKLASS_INLINE_HPP
< prev index next >