archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-18 10:04:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8288537: Move Devirtualizer out of hotspot/share/memory/iterator.hpp

Browse source 
Reviewed-by: stefank, coleenp
This commit is contained in:
Ioi Lam 2022-06-21 20:54:59 +00:00
parent f080430440
commit 9f8bfab290
15 changed files with 233 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

136
src/hotspot/share/memory/iterator.inline.hpp
View file

@ -63,142 +63,6 @@ inline void ClaimMetadataVisitingOopIterateClosure::do_method(Method* m) {
m->record_gc_epoch();
}
// Implementation of the non-virtual do_oop dispatch.
//
// The same implementation is used for do_metadata, do_klass, and do_cld.
//
// Preconditions:
// - Base has a pure virtual do_oop
// - Only one of the classes in the inheritance chain from OopClosureType to
// Base implements do_oop.
//
// Given the preconditions:
// - If &OopClosureType::do_oop is resolved to &Base::do_oop, then there is no
// implementation of do_oop between Base and OopClosureType. However, there
// must be one implementation in one of the subclasses of OopClosureType.
// In this case we take the virtual call.
//
// - Conversely, if &OopClosureType::do_oop is not resolved to &Base::do_oop,
// then we've found the one and only concrete implementation. In this case we
// take a non-virtual call.
//
// Because of this it's clear when we should call the virtual call and
// when the non-virtual call should be made.
//
// The way we find if &OopClosureType::do_oop is resolved to &Base::do_oop is to
// check if the resulting type of the class of a member-function pointer to
// &OopClosureType::do_oop is equal to the type of the class of a
// &Base::do_oop member-function pointer. Template parameter deduction is used
// to find these types, and then the IsSame trait is used to check if they are
// equal. Finally, SFINAE is used to select the appropriate implementation.
//
// Template parameters:
// T - narrowOop or oop
// Receiver - the resolved type of the class of the
// &OopClosureType::do_oop member-function pointer. That is,
// the klass with the do_oop member function.
// Base - klass with the pure virtual do_oop member function.
// OopClosureType - The dynamic closure type
//
// Parameters:
// closure - The closure to call
// p - The oop (or narrowOop) field to pass to the closure
template <typename T, typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<IsSame<Receiver, Base>::value, void>::type
call_do_oop(void (Receiver::*)(T*), void (Base::*)(T*), OopClosureType* closure, T* p) {
closure->do_oop(p);
}
template <typename T, typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<!IsSame<Receiver, Base>::value, void>::type
call_do_oop(void (Receiver::*)(T*), void (Base::*)(T*), OopClosureType* closure, T* p) {
// Sanity check
STATIC_ASSERT((!IsSame<OopClosureType, OopIterateClosure>::value));
closure->OopClosureType::do_oop(p);
}
template <typename OopClosureType, typename T>
inline void Devirtualizer::do_oop(OopClosureType* closure, T* p) {
call_do_oop<T>(&OopClosureType::do_oop, &OopClosure::do_oop, closure, p);
}
// Implementation of the non-virtual do_metadata dispatch.
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<IsSame<Receiver, Base>::value, bool>::type
call_do_metadata(bool (Receiver::*)(), bool (Base::*)(), OopClosureType* closure) {
return closure->do_metadata();
}
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<!IsSame<Receiver, Base>::value, bool>::type
call_do_metadata(bool (Receiver::*)(), bool (Base::*)(), OopClosureType* closure) {
return closure->OopClosureType::do_metadata();
}
template <typename OopClosureType>
inline bool Devirtualizer::do_metadata(OopClosureType* closure) {
return call_do_metadata(&OopClosureType::do_metadata, &OopIterateClosure::do_metadata, closure);
}
// Implementation of the non-virtual do_klass dispatch.
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<IsSame<Receiver, Base>::value, void>::type
call_do_klass(void (Receiver::*)(Klass*), void (Base::*)(Klass*), OopClosureType* closure, Klass* k) {
closure->do_klass(k);
}
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<!IsSame<Receiver, Base>::value, void>::type
call_do_klass(void (Receiver::*)(Klass*), void (Base::*)(Klass*), OopClosureType* closure, Klass* k) {
closure->OopClosureType::do_klass(k);
}
template <typename OopClosureType>
inline void Devirtualizer::do_klass(OopClosureType* closure, Klass* k) {
call_do_klass(&OopClosureType::do_klass, &OopIterateClosure::do_klass, closure, k);
}
// Implementation of the non-virtual do_cld dispatch.
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<IsSame<Receiver, Base>::value, void>::type
call_do_cld(void (Receiver::*)(ClassLoaderData*), void (Base::*)(ClassLoaderData*), OopClosureType* closure, ClassLoaderData* cld) {
closure->do_cld(cld);
}
template <typename Receiver, typename Base, typename OopClosureType>
static typename EnableIf<!IsSame<Receiver, Base>::value, void>::type
call_do_cld(void (Receiver::*)(ClassLoaderData*), void (Base::*)(ClassLoaderData*), OopClosureType* closure, ClassLoaderData* cld) {
closure->OopClosureType::do_cld(cld);
}
template <typename OopClosureType>
void Devirtualizer::do_cld(OopClosureType* closure, ClassLoaderData* cld) {
call_do_cld(&OopClosureType::do_cld, &OopIterateClosure::do_cld, closure, cld);
}
// Implementation of the non-virtual do_derived_oop dispatch.
template <typename Receiver, typename Base, typename DerivedOopClosureType>
static typename EnableIf<IsSame<Receiver, Base>::value, void>::type
call_do_derived_oop(void (Receiver::*)(oop*, derived_pointer*), void (Base::*)(oop*, derived_pointer*), DerivedOopClosureType* closure, oop* base, derived_pointer* derived) {
closure->do_derived_oop(base, derived);
}
template <typename Receiver, typename Base, typename DerivedOopClosureType>
static typename EnableIf<!IsSame<Receiver, Base>::value, void>::type
call_do_derived_oop(void (Receiver::*)(oop*, derived_pointer*), void (Base::*)(oop*, derived_pointer*), DerivedOopClosureType* closure, oop* base, derived_pointer* derived) {
closure->DerivedOopClosureType::do_derived_oop(base, derived);
}
template <typename DerivedOopClosureType>
inline void Devirtualizer::do_derived_oop(DerivedOopClosureType* closure, oop* base, derived_pointer* derived) {
call_do_derived_oop(&DerivedOopClosureType::do_derived_oop, &DerivedOopClosure::do_derived_oop, closure, base, derived);
}
// Dispatch table implementation for *Klass::oop_oop_iterate
//
// It allows for a single call to do a multi-dispatch to an optimized version