1 /* 2 * Copyright (c) 2017, 2021, 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_MEMORY_METASPACECLOSURE_HPP 26 #define SHARE_MEMORY_METASPACECLOSURE_HPP 27 28 #include "logging/log.hpp" 29 #include "memory/allocation.hpp" 30 #include "metaprogramming/enableIf.hpp" 31 #include "oops/array.hpp" 32 #include "utilities/globalDefinitions.hpp" 33 #include "utilities/growableArray.hpp" 34 #include "utilities/macros.hpp" 35 #include "utilities/resizeableResourceHash.hpp" 36 #include <type_traits> 37 38 // The metadata hierarchy is separate from the oop hierarchy 39 class MetaspaceObj; // no C++ vtable 40 //class Array; // no C++ vtable 41 class Annotations; // no C++ vtable 42 class ConstantPoolCache; // no C++ vtable 43 class ConstMethod; // no C++ vtable 44 class MethodCounters; // no C++ vtable 45 class Symbol; // no C++ vtable 46 class Metadata; // has C++ vtable (so do all subclasses) 47 class ConstantPool; 48 class MethodData; 49 class Method; 50 class Klass; 51 class InstanceKlass; 52 class InstanceMirrorKlass; 53 class InstanceClassLoaderKlass; 54 class InstanceRefKlass; 55 class ArrayKlass; 56 class ObjArrayKlass; 57 class TypeArrayKlass; 58 59 // class MetaspaceClosure -- 60 // 61 // This class is used for iterating the objects in the HotSpot Metaspaces. It 62 // provides an API to walk all the reachable objects starting from a set of 63 // root references (such as all Klass'es in the SystemDictionary). 64 // 65 // Currently it is used for compacting the CDS archive by eliminate temporary 66 // objects allocated during archive creation time. See ArchiveBuilder for an example. 67 // 68 // To support MetaspaceClosure, each subclass of MetaspaceObj must provide 69 // a method of the type void metaspace_pointers_do(MetaspaceClosure*). This method 70 // should call MetaspaceClosure::push() on every pointer fields of this 71 // class that points to a MetaspaceObj. See Annotations::metaspace_pointers_do() 72 // for an example. 73 class MetaspaceClosure { 74 public: 75 enum Writability { 76 _writable, 77 _not_writable, 78 _default 79 }; 80 81 enum SpecialRef { 82 // A field that points to a method entry. E.g., Method::_i2i_entry 83 _method_entry_ref, 84 85 // A field that points to a location inside the current object. 86 _internal_pointer_ref, 87 }; 88 89 // class MetaspaceClosure::Ref -- 90 // 91 // MetaspaceClosure can be viewed as a very simple type of copying garbage 92 // collector. For it to function properly, it requires each subclass of 93 // MetaspaceObj to provide two methods: 94 // 95 // size_t size(); -- to determine how much data to copy 96 // void metaspace_pointers_do(MetaspaceClosure*); -- to locate all the embedded pointers 97 // 98 // Calling these methods would be trivial if these two were virtual methods. 99 // However, to save space, MetaspaceObj has NO vtable. The vtable is introduced 100 // only in the Metadata class. 101 // 102 // To work around the lack of a vtable, we use the Ref class with templates 103 // (see MSORef, OtherArrayRef, MSOArrayRef, and MSOPointerArrayRef) 104 // so that we can statically discover the type of a object. The use of Ref 105 // depends on the fact that: 106 // 107 // [1] We don't use polymorphic pointers for MetaspaceObj's that are not subclasses 108 // of Metadata. I.e., we don't do this: 109 // class Klass { 110 // MetaspaceObj *_obj; 111 // Array<int>* foo() { return (Array<int>*)_obj; } 112 // Symbol* bar() { return (Symbol*) _obj; } 113 // 114 // [2] All Array<T> dimensions are statically declared. 115 class Ref : public CHeapObj<mtMetaspace> { 116 Writability _writability; 117 bool _keep_after_pushing; 118 Ref* _next; 119 void* _user_data; 120 NONCOPYABLE(Ref); 121 122 protected: 123 virtual void** mpp() const = 0; 124 Ref(Writability w) : _writability(w), _keep_after_pushing(false), _next(NULL), _user_data(NULL) {} 125 public: 126 virtual bool not_null() const = 0; 127 virtual int size() const = 0; 128 virtual void metaspace_pointers_do(MetaspaceClosure *it) const = 0; 129 virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const = 0; 130 virtual MetaspaceObj::Type msotype() const = 0; 131 virtual bool is_read_only_by_default() const = 0; 132 virtual ~Ref() {} 133 134 address obj() const { 135 return *addr(); 136 } 137 138 address* addr() const { 139 return (address*)mpp(); 140 } 141 142 void update(address new_loc) const; 143 144 Writability writability() const { return _writability; }; 145 void set_keep_after_pushing() { _keep_after_pushing = true; } 146 bool keep_after_pushing() { return _keep_after_pushing; } 147 void set_user_data(void* data) { _user_data = data; } 148 void* user_data() { return _user_data; } 149 void set_next(Ref* n) { _next = n; } 150 Ref* next() const { return _next; } 151 }; 152 153 private: 154 // MSORef -- iterate an instance of MetaspaceObj 155 template <class T> class MSORef : public Ref { 156 T** _mpp; 157 T* dereference() const { 158 return *_mpp; 159 } 160 protected: 161 virtual void** mpp() const { 162 return (void**)_mpp; 163 } 164 165 public: 166 MSORef(T** mpp, Writability w) : Ref(w), _mpp(mpp) {} 167 168 virtual bool is_read_only_by_default() const { return T::is_read_only_by_default(); } 169 virtual bool not_null() const { return dereference() != NULL; } 170 virtual int size() const { return dereference()->size(); } 171 virtual MetaspaceObj::Type msotype() const { return dereference()->type(); } 172 173 virtual void metaspace_pointers_do(MetaspaceClosure *it) const { 174 dereference()->metaspace_pointers_do(it); 175 } 176 virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { 177 ((T*)new_loc)->metaspace_pointers_do(it); 178 } 179 }; 180 181 // abstract base class for MSOArrayRef, MSOPointerArrayRef and OtherArrayRef 182 template <class T> class ArrayRef : public Ref { 183 Array<T>** _mpp; 184 protected: 185 Array<T>* dereference() const { 186 return *_mpp; 187 } 188 virtual void** mpp() const { 189 return (void**)_mpp; 190 } 191 192 ArrayRef(Array<T>** mpp, Writability w) : Ref(w), _mpp(mpp) {} 193 194 // all Arrays are read-only by default 195 virtual bool is_read_only_by_default() const { return true; } 196 virtual bool not_null() const { return dereference() != NULL; } 197 virtual int size() const { return dereference()->size(); } 198 virtual MetaspaceObj::Type msotype() const { return MetaspaceObj::array_type(sizeof(T)); } 199 }; 200 201 // OtherArrayRef -- iterate an instance of Array<T>, where T is NOT a subtype of MetaspaceObj. 202 // T can be a primitive type, such as int, or a structure. However, we do not scan 203 // the fields inside T, so you should not embed any pointers inside T. 204 template <class T> class OtherArrayRef : public ArrayRef<T> { 205 public: 206 OtherArrayRef(Array<T>** mpp, Writability w) : ArrayRef<T>(mpp, w) {} 207 208 virtual void metaspace_pointers_do(MetaspaceClosure *it) const { 209 Array<T>* array = ArrayRef<T>::dereference(); 210 log_trace(cds)("Iter(OtherArray): %p [%d]", array, array->length()); 211 } 212 virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { 213 Array<T>* array = (Array<T>*)new_loc; 214 log_trace(cds)("Iter(OtherArray): %p [%d]", array, array->length()); 215 } 216 }; 217 218 // MSOArrayRef -- iterate an instance of Array<T>, where T is a subtype of MetaspaceObj. 219 // We recursively call T::metaspace_pointers_do() for each element in this array. 220 template <class T> class MSOArrayRef : public ArrayRef<T> { 221 public: 222 MSOArrayRef(Array<T>** mpp, Writability w) : ArrayRef<T>(mpp, w) {} 223 224 virtual void metaspace_pointers_do(MetaspaceClosure *it) const { 225 metaspace_pointers_do_at_impl(it, ArrayRef<T>::dereference()); 226 } 227 virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { 228 metaspace_pointers_do_at_impl(it, (Array<T>*)new_loc); 229 } 230 private: 231 void metaspace_pointers_do_at_impl(MetaspaceClosure *it, Array<T>* array) const { 232 log_trace(cds)("Iter(MSOArray): %p [%d]", array, array->length()); 233 for (int i = 0; i < array->length(); i++) { 234 T* elm = array->adr_at(i); 235 elm->metaspace_pointers_do(it); 236 } 237 } 238 }; 239 240 // MSOPointerArrayRef -- iterate an instance of Array<T*>, where T is a subtype of MetaspaceObj. 241 // We recursively call MetaspaceClosure::push() for each pointer in this array. 242 template <class T> class MSOPointerArrayRef : public ArrayRef<T*> { 243 public: 244 MSOPointerArrayRef(Array<T*>** mpp, Writability w) : ArrayRef<T*>(mpp, w) {} 245 246 virtual void metaspace_pointers_do(MetaspaceClosure *it) const { 247 metaspace_pointers_do_at_impl(it, ArrayRef<T*>::dereference()); 248 } 249 virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { 250 metaspace_pointers_do_at_impl(it, (Array<T*>*)new_loc); 251 } 252 private: 253 void metaspace_pointers_do_at_impl(MetaspaceClosure *it, Array<T*>* array) const { 254 log_trace(cds)("Iter(MSOPointerArray): %p [%d]", array, array->length()); 255 for (int i = 0; i < array->length(); i++) { 256 T** mpp = array->adr_at(i); 257 it->push(mpp); 258 } 259 } 260 }; 261 262 // Normally, chains of references like a->b->c->d are iterated recursively. However, 263 // if recursion is too deep, we save the Refs in _pending_refs, and push them later in 264 // MetaspaceClosure::finish(). This avoids overflowing the C stack. 265 static const int MAX_NEST_LEVEL = 5; 266 Ref* _pending_refs; 267 int _nest_level; 268 Ref* _enclosing_ref; 269 270 void push_impl(Ref* ref); 271 void do_push(Ref* ref); 272 273 public: 274 MetaspaceClosure(): _pending_refs(NULL), _nest_level(0), _enclosing_ref(NULL) {} 275 ~MetaspaceClosure(); 276 277 void finish(); 278 279 // enclosing_ref() is used to compute the offset of a field in a C++ class. For example 280 // class Foo { intx scala; Bar* ptr; } 281 // Foo *f = 0x100; 282 // when the f->ptr field is iterated with do_ref() on 64-bit platforms, we will have 283 // do_ref(Ref* r) { 284 // r->addr() == 0x108; // == &f->ptr; 285 // enclosing_ref()->obj() == 0x100; // == foo 286 // So we know that we are iterating upon a field at offset 8 of the object at 0x100. 287 // 288 // Note that if we have stack overflow, do_pending_ref(r) will be called first and 289 // do_ref(r) will be called later, for the same r. In this case, enclosing_ref() is valid only 290 // when do_pending_ref(r) is called, and will return NULL when do_ref(r) is called. 291 Ref* enclosing_ref() const { 292 return _enclosing_ref; 293 } 294 295 // This is called when a reference is placed in _pending_refs. Override this 296 // function if you're using enclosing_ref(). See notes above. 297 virtual void do_pending_ref(Ref* ref) {} 298 299 // returns true if we want to keep iterating the pointers embedded inside <ref> 300 virtual bool do_ref(Ref* ref, bool read_only) = 0; 301 302 private: 303 template <class REF_TYPE, typename T> 304 void push_with_ref(T** mpp, Writability w) { 305 push_impl(new REF_TYPE(mpp, w)); 306 } 307 308 public: 309 // When MetaspaceClosure::push(...) is called, pick the correct Ref subtype to handle it: 310 // 311 // MetaspaceClosure* it = ...; 312 // Klass* o = ...; it->push(&o); => MSORef 313 // Array<int>* a1 = ...; it->push(&a1); => OtherArrayRef 314 // Array<Annotation>* a2 = ...; it->push(&a2); => MSOArrayRef 315 // Array<Klass*>* a3 = ...; it->push(&a3); => MSOPointerArrayRef 316 // Array<Array<Klass*>*>* a4 = ...; it->push(&a4); => MSOPointerArrayRef 317 // Array<Annotation*>* a5 = ...; it->push(&a5); => MSOPointerArrayRef 318 // 319 // Note that the following will fail to compile (to prevent you from adding new fields 320 // into the MetaspaceObj subtypes that cannot be properly copied by CDS): 321 // 322 // Hashtable* h = ...; it->push(&h); => Hashtable is not a subclass of MetaspaceObj 323 // Array<Hashtable*>* a6 = ...; it->push(&a6); => Hashtable is not a subclass of MetaspaceObj 324 // Array<int*>* a7 = ...; it->push(&a7); => int is not a subclass of MetaspaceObj 325 326 template <typename T> 327 void push(T** mpp, Writability w = _default) { 328 static_assert(std::is_base_of<MetaspaceObj, T>::value, "Do not push pointers of arbitrary types"); 329 push_with_ref<MSORef<T>>(mpp, w); 330 } 331 332 template <typename T, ENABLE_IF(!std::is_base_of<MetaspaceObj, T>::value)> 333 void push(Array<T>** mpp, Writability w = _default) { 334 push_with_ref<OtherArrayRef<T>>(mpp, w); 335 } 336 337 template <typename T, ENABLE_IF(std::is_base_of<MetaspaceObj, T>::value)> 338 void push(Array<T>** mpp, Writability w = _default) { 339 push_with_ref<MSOArrayRef<T>>(mpp, w); 340 } 341 342 template <typename T> 343 void push(Array<T*>** mpp, Writability w = _default) { 344 static_assert(std::is_base_of<MetaspaceObj, T>::value, "Do not push Arrays of arbitrary pointer types"); 345 push_with_ref<MSOPointerArrayRef<T>>(mpp, w); 346 } 347 348 #if 0 349 // Enable this block if you're changing the push(...) methods, to test for types that should be 350 // disallowed. Each of the following "push" calls should result in a compile-time error. 351 void test_disallowed_types(MetaspaceClosure* it) { 352 Hashtable<bool, mtInternal>* h = NULL; 353 it->push(&h); 354 355 Array<Hashtable<bool, mtInternal>*>* a6 = NULL; 356 it->push(&a6); 357 358 Array<int*>* a7 = NULL; 359 it->push(&a7); 360 } 361 #endif 362 363 template <class T> void push_method_entry(T** mpp, intptr_t* p) { 364 Ref* ref = new MSORef<T>(mpp, _default); 365 push_special(_method_entry_ref, ref, p); 366 if (!ref->keep_after_pushing()) { 367 delete ref; 368 } 369 } 370 371 template <class T> void push_internal_pointer(T** mpp, intptr_t* p) { 372 Ref* ref = new MSORef<T>(mpp, _default); 373 push_special(_internal_pointer_ref, ref, p); 374 if (!ref->keep_after_pushing()) { 375 delete ref; 376 } 377 } 378 379 // This is for tagging special pointers that are not a reference to MetaspaceObj. It's currently 380 // used to mark the method entry points in Method/ConstMethod. 381 virtual void push_special(SpecialRef type, Ref* obj, intptr_t* p) { 382 assert_valid(type); 383 } 384 385 static void assert_valid(SpecialRef type) { 386 assert(type == _method_entry_ref || type == _internal_pointer_ref, "only special types allowed for now"); 387 } 388 }; 389 390 // This is a special MetaspaceClosure that visits each unique MetaspaceObj once. 391 class UniqueMetaspaceClosure : public MetaspaceClosure { 392 static const int INITIAL_TABLE_SIZE = 15889; 393 static const int MAX_TABLE_SIZE = 1000000; 394 395 // Do not override. Returns true if we are discovering ref->obj() for the first time. 396 virtual bool do_ref(Ref* ref, bool read_only); 397 398 public: 399 // Gets called the first time we discover an object. 400 virtual bool do_unique_ref(Ref* ref, bool read_only) = 0; 401 UniqueMetaspaceClosure() : _has_been_visited(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE) {} 402 403 private: 404 ResizeableResourceHashtable<address, bool, ResourceObj::C_HEAP, 405 mtClassShared> _has_been_visited; 406 }; 407 408 #endif // SHARE_MEMORY_METASPACECLOSURE_HPP