1 /* 2 * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 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_OOPS_INSTANCEKLASS_INLINE_HPP 26 #define SHARE_OOPS_INSTANCEKLASS_INLINE_HPP 27 28 #include "oops/instanceKlass.hpp" 29 30 #include "memory/memRegion.hpp" 31 #include "oops/fieldInfo.inline.hpp" 32 #include "oops/klass.inline.hpp" 33 #include "oops/oop.inline.hpp" 34 #include "runtime/atomic.hpp" 35 #include "utilities/devirtualizer.inline.hpp" 36 #include "utilities/globalDefinitions.hpp" 37 38 inline intptr_t* InstanceKlass::start_of_itable() const { return (intptr_t*)start_of_vtable() + vtable_length(); } 39 inline intptr_t* InstanceKlass::end_of_itable() const { return start_of_itable() + itable_length(); } 40 41 inline oop InstanceKlass::static_field_base_raw() { return java_mirror(); } 42 43 inline Symbol* InstanceKlass::field_name(int index) const { return field(index).name(constants()); } 44 inline Symbol* InstanceKlass::field_signature(int index) const { return field(index).signature(constants()); } 45 46 inline int InstanceKlass::java_fields_count() const { return FieldInfoStream::num_java_fields(fieldinfo_stream()); } 47 inline int InstanceKlass::total_fields_count() const { return FieldInfoStream::num_total_fields(fieldinfo_stream()); } 48 49 inline OopMapBlock* InstanceKlass::start_of_nonstatic_oop_maps() const { 50 return (OopMapBlock*)(start_of_itable() + itable_length()); 51 } 52 53 inline Klass** InstanceKlass::end_of_nonstatic_oop_maps() const { 54 return (Klass**)(start_of_nonstatic_oop_maps() + 55 nonstatic_oop_map_count()); 56 } 57 58 inline InstanceKlass* volatile* InstanceKlass::adr_implementor() const { 59 if (is_interface()) { 60 return (InstanceKlass* volatile*)end_of_nonstatic_oop_maps(); 61 } else { 62 return nullptr; 63 } 64 } 65 66 inline ObjArrayKlass* InstanceKlass::array_klasses_acquire() const { 67 return Atomic::load_acquire(&_array_klasses); 68 } 69 70 inline void InstanceKlass::release_set_array_klasses(ObjArrayKlass* k) { 71 Atomic::release_store(&_array_klasses, k); 72 } 73 74 // The iteration over the oops in objects is a hot path in the GC code. 75 // By force inlining the following functions, we get similar GC performance 76 // as the previous macro based implementation. 77 78 template <typename T, class OopClosureType> 79 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure) { 80 T* p = obj->field_addr<T>(map->offset()); 81 T* const end = p + map->count(); 82 83 for (; p < end; ++p) { 84 Devirtualizer::do_oop(closure, p); 85 } 86 } 87 88 template <typename T, class OopClosureType> 89 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_reverse(OopMapBlock* map, oop obj, OopClosureType* closure) { 90 T* const start = obj->field_addr<T>(map->offset()); 91 T* p = start + map->count(); 92 93 while (start < p) { 94 --p; 95 Devirtualizer::do_oop(closure, p); 96 } 97 } 98 99 template <typename T, class OopClosureType> 100 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_bounded(OopMapBlock* map, oop obj, OopClosureType* closure, MemRegion mr) { 101 T* p = obj->field_addr<T>(map->offset()); 102 T* end = p + map->count(); 103 104 T* const l = (T*)mr.start(); 105 T* const h = (T*)mr.end(); 106 assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 && 107 mask_bits((intptr_t)h, sizeof(T)-1) == 0, 108 "bounded region must be properly aligned"); 109 110 if (p < l) { 111 p = l; 112 } 113 if (end > h) { 114 end = h; 115 } 116 117 for (;p < end; ++p) { 118 Devirtualizer::do_oop(closure, p); 119 } 120 } 121 122 template <typename T, class OopClosureType> 123 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure) { 124 OopMapBlock* map = start_of_nonstatic_oop_maps(); 125 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); 126 127 for (; map < end_map; ++map) { 128 oop_oop_iterate_oop_map<T>(map, obj, closure); 129 } 130 } 131 132 template <typename T, class OopClosureType> 133 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_reverse(oop obj, OopClosureType* closure) { 134 OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); 135 OopMapBlock* map = start_map + nonstatic_oop_map_count(); 136 137 while (start_map < map) { 138 --map; 139 oop_oop_iterate_oop_map_reverse<T>(map, obj, closure); 140 } 141 } 142 143 template <typename T, class OopClosureType> 144 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_bounded(oop obj, OopClosureType* closure, MemRegion mr) { 145 OopMapBlock* map = start_of_nonstatic_oop_maps(); 146 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); 147 148 for (;map < end_map; ++map) { 149 oop_oop_iterate_oop_map_bounded<T>(map, obj, closure, mr); 150 } 151 } 152 153 template <typename T, class OopClosureType> 154 ALWAYSINLINE void InstanceKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { 155 if (Devirtualizer::do_metadata(closure)) { 156 Devirtualizer::do_klass(closure, this); 157 } 158 159 oop_oop_iterate_oop_maps<T>(obj, closure); 160 } 161 162 template <typename T, class OopClosureType> 163 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { 164 assert(!Devirtualizer::do_metadata(closure), 165 "Code to handle metadata is not implemented"); 166 167 oop_oop_iterate_oop_maps_reverse<T>(obj, closure); 168 } 169 170 template <typename T, class OopClosureType> 171 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { 172 if (Devirtualizer::do_metadata(closure)) { 173 if (mr.contains(obj)) { 174 Devirtualizer::do_klass(closure, this); 175 } 176 } 177 178 oop_oop_iterate_oop_maps_bounded<T>(obj, closure, mr); 179 } 180 181 #endif // SHARE_OOPS_INSTANCEKLASS_INLINE_HPP