kern: devirtualize KAutoObjectWithList::GetId()

libraries/libmesosphere/include/mesosphere.hpp

@@ -90,3 +90,6 @@
 
 /* Main functionality. */
 #include <mesosphere/kern_main.hpp>
+
+/* Deferred includes. */
+#include <mesosphere/kern_k_auto_object_impls.hpp>

libraries/libmesosphere/include/mesosphere/kern_k_auto_object.hpp

@@ -230,8 +230,6 @@ namespace ams::kern {
             }
     };
 
-    class KAutoObjectWithListContainer;
-
     class KAutoObjectWithListBase : public KAutoObject {
         private:
             void *m_alignment_forcer_unused[0];
@@ -243,6 +241,7 @@ namespace ams::kern {
 
     class KAutoObjectWithList : public KAutoObjectWithListBase {
         private:
+            template<typename>
             friend class KAutoObjectWithListContainer;
         private:
             util::IntrusiveRedBlackTreeNode m_list_node;
@@ -250,28 +249,8 @@ namespace ams::kern {
             constexpr ALWAYS_INLINE KAutoObjectWithList(util::ConstantInitializeTag) : KAutoObjectWithListBase(util::ConstantInitialize), m_list_node(util::ConstantInitialize) { /* ... */ }
             ALWAYS_INLINE explicit KAutoObjectWithList() { /* ... */ }
         public:
-            using RedBlackKeyType = u64;
+            /* NOTE: This is virtual in Nintendo's kernel. */
-
+            u64 GetId() const;
-            static constexpr ALWAYS_INLINE RedBlackKeyType GetRedBlackKey(const RedBlackKeyType     &v) { return v; }
-            static constexpr ALWAYS_INLINE RedBlackKeyType GetRedBlackKey(const KAutoObjectWithList &v) { return v.GetId(); }
-
-            template<typename T> requires (std::same_as<T, KAutoObjectWithList> || std::same_as<T, RedBlackKeyType>)
-            static ALWAYS_INLINE int Compare(const T &lhs, const KAutoObjectWithList &rhs) {
-                const u64 lid = GetRedBlackKey(lhs);
-                const u64 rid = GetRedBlackKey(rhs);
-
-                if (lid < rid) {
-                    return -1;
-                } else if (lid > rid) {
-                    return 1;
-                } else {
-                    return 0;
-                }
-            }
-        public:
-            virtual u64 GetId() const {
-                return reinterpret_cast<u64>(this);
-            }
     };
 
     template<typename T> requires std::derived_from<T, KAutoObject>

libraries/libmesosphere/include/mesosphere/kern_k_auto_object_container.hpp

@@ -20,77 +20,129 @@
 
 namespace ams::kern {
 
-    class KAutoObjectWithListContainer {
+    namespace impl {
-        NON_COPYABLE(KAutoObjectWithListContainer);
-        NON_MOVEABLE(KAutoObjectWithListContainer);
-        public:
-            using ListType = util::IntrusiveRedBlackTreeMemberTraits<&KAutoObjectWithList::m_list_node>::TreeType<KAutoObjectWithList>;
-        public:
-            class ListAccessor : public KScopedLightLock {
-                private:
-                    ListType &m_list;
-                public:
-                    explicit ListAccessor(KAutoObjectWithListContainer *container) : KScopedLightLock(container->m_lock), m_list(container->m_object_list) { /* ... */ }
-                    explicit ListAccessor(KAutoObjectWithListContainer &container) : KScopedLightLock(container.m_lock), m_list(container.m_object_list) { /* ... */ }
 
-                    ALWAYS_INLINE typename ListType::iterator begin() const {
+        template<typename T>
-                        return m_list.begin();
+        struct GetAutoObjectWithListComparator;
-                    }
 
-                    ALWAYS_INLINE typename ListType::iterator end() const {
+        class KAutoObjectWithListContainerBase {
-                        return m_list.end();
+            NON_COPYABLE(KAutoObjectWithListContainerBase);
-                    }
+            NON_MOVEABLE(KAutoObjectWithListContainerBase);
+            protected:
+                template<typename ListType>
+                class ListAccessorImpl {
+                    NON_COPYABLE(ListAccessorImpl);
+                    NON_MOVEABLE(ListAccessorImpl);
+                    private:
+                        KScopedLightLock m_lk;
+                        ListType &m_list;
+                    public:
+                        explicit ALWAYS_INLINE ListAccessorImpl(KAutoObjectWithListContainerBase *container, ListType &list) : m_lk(container->m_lock), m_list(list) { /* ... */ }
+                        explicit ALWAYS_INLINE ListAccessorImpl(KAutoObjectWithListContainerBase &container, ListType &list) : m_lk(container.m_lock), m_list(list) { /* ... */ }
 
-                    ALWAYS_INLINE typename ListType::iterator find(typename ListType::const_reference ref) const {
+                        ALWAYS_INLINE ~ListAccessorImpl() { /* ... */ }
-                        return m_list.find(ref);
-                    }
 
-                    ALWAYS_INLINE typename ListType::iterator find_key(typename ListType::const_key_reference ref) const {
+                        ALWAYS_INLINE typename ListType::iterator begin() const {
-                        return m_list.find_key(ref);
+                            return m_list.begin();
-                    }
+                        }
-            };
 
-            friend class ListAccessor;
+                        ALWAYS_INLINE typename ListType::iterator end() const {
-        private:
+                            return m_list.end();
-            KLightLock m_lock;
+                        }
-            ListType m_object_list;
-        public:
-            constexpr KAutoObjectWithListContainer() : m_lock(), m_object_list() { MESOSPHERE_ASSERT_THIS(); }
 
-            void Initialize() { MESOSPHERE_ASSERT_THIS(); }
+                        ALWAYS_INLINE typename ListType::iterator find(typename ListType::const_reference ref) const {
-            void Finalize() { MESOSPHERE_ASSERT_THIS(); }
+                            return m_list.find(ref);
+                        }
 
-            void Register(KAutoObjectWithList *obj) {
+                        ALWAYS_INLINE typename ListType::iterator find_key(typename ListType::const_key_reference ref) const {
-                MESOSPHERE_ASSERT_THIS();
+                            return m_list.find_key(ref);
+                        }
+                };
 
-                KScopedLightLock lk(m_lock);
+                template<typename ListType>
+                friend class ListAccessorImpl;
+            private:
+                KLightLock m_lock;
+            protected:
+                constexpr KAutoObjectWithListContainerBase() : m_lock() { /* ... */ }
 
-                m_object_list.insert(*obj);
+                ALWAYS_INLINE void InitializeImpl() { MESOSPHERE_ASSERT_THIS(); }
-            }
+                ALWAYS_INLINE void FinalizeImpl() { MESOSPHERE_ASSERT_THIS(); }
 
-            void Unregister(KAutoObjectWithList *obj) {
+                template<typename ListType>
-                MESOSPHERE_ASSERT_THIS();
+                void RegisterImpl(KAutoObjectWithList *obj, ListType &list) {
+                    MESOSPHERE_ASSERT_THIS();
 
-                KScopedLightLock lk(m_lock);
+                    KScopedLightLock lk(m_lock);
 
-                m_object_list.erase(m_object_list.iterator_to(*obj));
+                    list.insert(*obj);
-            }
-
-            template<typename T> requires (std::derived_from<T, KAutoObjectWithList> && requires (const T &t) { { t.GetOwner() } -> std::convertible_to<const KProcess *>; })
-            size_t GetOwnedCount(const KProcess *owner) {
-                MESOSPHERE_ASSERT_THIS();
-
-                KScopedLightLock lk(m_lock);
-
-                size_t count = 0;
-
-                for (const auto &obj : m_object_list) {
-                    if (const T * const derived = obj.DynamicCast<T *>(); derived != nullptr && derived->GetOwner() == owner) {
-                        ++count;
-                    }
                 }
 
-                return count;
+                template<typename ListType>
+                void UnregisterImpl(KAutoObjectWithList *obj, ListType &list) {
+                    MESOSPHERE_ASSERT_THIS();
+
+                    KScopedLightLock lk(m_lock);
+
+                    list.erase(list.iterator_to(*obj));
+                }
+
+                template<typename U, typename ListType>
+                size_t GetOwnedCountImpl(const KProcess *owner, ListType &list) {
+                    MESOSPHERE_ASSERT_THIS();
+
+                    KScopedLightLock lk(m_lock);
+
+                    size_t count = 0;
+
+                    for (const auto &obj : list) {
+                        AMS_AUDIT(obj.DynamicCast<const U *>() != nullptr);
+                        if (static_cast<const U &>(obj).GetOwner() == owner) {
+                            ++count;
+                        }
+                    }
+
+                    return count;
+                }
+        };
+
+        struct DummyKAutoObjectWithListComparator {
+            static NOINLINE int Compare(KAutoObjectWithList &lhs, KAutoObjectWithList &rhs) {
+                AMS_ASSUME(false);
+            }
+        };
+
+    }
+
+    template<typename T>
+    class KAutoObjectWithListContainer : public impl::KAutoObjectWithListContainerBase {
+        private:
+            using Base = impl::KAutoObjectWithListContainerBase;
+        public:
+            class ListAccessor;
+            friend class ListAccessor;
+
+            template<typename Comparator>
+            using ListType = util::IntrusiveRedBlackTreeMemberTraits<&KAutoObjectWithList::m_list_node>::TreeType<Comparator>;
+
+            using DummyListType = ListType<impl::DummyKAutoObjectWithListComparator>;
+        private:
+            DummyListType m_dummy_object_list;
+        public:
+            constexpr ALWAYS_INLINE KAutoObjectWithListContainer() : Base(), m_dummy_object_list() { static_assert(std::derived_from<T, KAutoObjectWithList>); }
+
+            ALWAYS_INLINE void Initialize() { return this->InitializeImpl(); }
+            ALWAYS_INLINE void Finalize() { return this->FinalizeImpl(); }
+
+            void Register(T *obj);
+            void Unregister(T *obj);
+
+        private:
+            size_t GetOwnedCountChecked(const KProcess *owner);
+        public:
+            template<typename U> requires (std::same_as<U, T> && requires (const U &u) { { u.GetOwner() } -> std::convertible_to<const KProcess *>; })
+            ALWAYS_INLINE size_t GetOwnedCount(const KProcess *owner) {
+                return this->GetOwnedCountChecked(owner);
             }
     };
 

libraries/libmesosphere/include/mesosphere/kern_k_auto_object_impls.hpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <mesosphere/kern_common.hpp>
+#include <mesosphere/kern_k_class_token.hpp>
+
+namespace ams::kern {
+
+    /* NOTE: This header is included after all other KAutoObjects. */
+    namespace impl {
+
+        template<typename T> requires std::derived_from<T, KAutoObject>
+        consteval bool IsAutoObjectInheritanceValidImpl() {
+            #define CLASS_TOKEN_HANDLER(CLASSNAME)                                                                               \
+                if constexpr (std::same_as<T, CLASSNAME>) {                                                                      \
+                    if (T::GetStaticTypeObj().GetClassToken() != ::ams::kern::ClassToken<CLASSNAME>) {                           \
+                        return false;                                                                                            \
+                    }                                                                                                            \
+                } else {                                                                                                         \
+                    if (T::GetStaticTypeObj().IsDerivedFrom(CLASSNAME::GetStaticTypeObj()) != std::derived_from<T, CLASSNAME>) { \
+                        return false;                                                                                            \
+                    }                                                                                                            \
+                }
+
+            FOR_EACH_K_CLASS_TOKEN_OBJECT_TYPE(CLASS_TOKEN_HANDLER)
+            #undef CLASS_TOKEN_HANDLER
+
+            return true;
+        }
+
+        consteval bool IsEveryAutoObjectInheritanceValid() {
+            #define CLASS_TOKEN_HANDLER(CLASSNAME) if (!IsAutoObjectInheritanceValidImpl<CLASSNAME>()) { return false; }
+            FOR_EACH_K_CLASS_TOKEN_OBJECT_TYPE(CLASS_TOKEN_HANDLER)
+            #undef CLASS_TOKEN_HANDLER
+
+            return true;
+        }
+
+        static_assert(IsEveryAutoObjectInheritanceValid());
+
+        template<typename T>
+        concept IsAutoObjectWithSpecializedGetId = std::derived_from<T, KAutoObjectWithList> && requires (const T &t, const KAutoObjectWithList &l) {
+            { t.GetIdImpl() } -> std::same_as<decltype(l.GetId())>;
+        };
+
+        template<typename T>
+        struct AutoObjectWithListComparatorImpl {
+            using RedBlackKeyType = u64;
+
+            static ALWAYS_INLINE RedBlackKeyType GetRedBlackKey(const RedBlackKeyType &v) { return v; }
+
+            static ALWAYS_INLINE RedBlackKeyType GetRedBlackKey(const KAutoObjectWithList &v) {
+                if constexpr (IsAutoObjectWithSpecializedGetId<T>) {
+                    return static_cast<const T &>(v).GetIdImpl();
+                } else {
+                    return reinterpret_cast<u64>(std::addressof(v));
+                }
+            }
+
+            template<typename U> requires (std::same_as<U, KAutoObjectWithList> || std::same_as<U, RedBlackKeyType>)
+            static ALWAYS_INLINE int Compare(const U &lhs, const KAutoObjectWithList &rhs) {
+                const u64 lid = GetRedBlackKey(lhs);
+                const u64 rid = GetRedBlackKey(rhs);
+
+                if (lid < rid) {
+                    return -1;
+                } else if (lid > rid) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+        };
+
+        template<typename T>
+        using AutoObjectWithListComparator = AutoObjectWithListComparatorImpl<typename std::conditional<IsAutoObjectWithSpecializedGetId<T>, T, KAutoObjectWithList>::type>;
+
+        template<typename T>
+        using TrueObjectContainerListType = typename KAutoObjectWithListContainer<T>::ListType<AutoObjectWithListComparator<T>>;
+
+        template<typename T>
+        ALWAYS_INLINE TrueObjectContainerListType<T> &GetTrueObjectContainerList(typename KAutoObjectWithListContainer<T>::DummyListType &l) {
+            static_assert(alignof(l) == alignof(impl::TrueObjectContainerListType<T>));
+            static_assert(sizeof(l)  == sizeof(impl::TrueObjectContainerListType<T>));
+            return *reinterpret_cast<TrueObjectContainerListType<T> *>(std::addressof(l));
+        }
+
+    }
+
+    ALWAYS_INLINE void KAutoObject::ScheduleDestruction() {
+        MESOSPHERE_ASSERT_THIS();
+
+        /* Set our object to destroy. */
+        m_next_closed_object = GetCurrentThread().GetClosedObject();
+
+        /* Set ourselves as the thread's next object to destroy. */
+        GetCurrentThread().SetClosedObject(this);
+    }
+
+    template<typename T>
+    class KAutoObjectWithListContainer<T>::ListAccessor : public impl::KAutoObjectWithListContainerBase::ListAccessorImpl<impl::TrueObjectContainerListType<T>> {
+        NON_COPYABLE(ListAccessor);
+        NON_MOVEABLE(ListAccessor);
+        private:
+            using BaseListAccessor = impl::KAutoObjectWithListContainerBase::ListAccessorImpl<impl::TrueObjectContainerListType<T>>;
+        public:
+            explicit ALWAYS_INLINE ListAccessor(KAutoObjectWithListContainer *container) : BaseListAccessor(container, impl::GetTrueObjectContainerList<T>(container->m_dummy_object_list)) { /* ... */ }
+            explicit ALWAYS_INLINE ListAccessor(KAutoObjectWithListContainer &container) : BaseListAccessor(container, impl::GetTrueObjectContainerList<T>(container.m_dummy_object_list)) { /* ... */ }
+
+            ALWAYS_INLINE ~ListAccessor() { /* ... */ }
+    };
+
+
+    template<typename T>
+    ALWAYS_INLINE void KAutoObjectWithListContainer<T>::Register(T *obj) {
+        return this->RegisterImpl(obj, impl::GetTrueObjectContainerList<T>(m_dummy_object_list));
+    }
+
+    template<typename T>
+    ALWAYS_INLINE void KAutoObjectWithListContainer<T>::Unregister(T *obj) {
+        return this->UnregisterImpl(obj, impl::GetTrueObjectContainerList<T>(m_dummy_object_list));
+    }
+
+    template<typename T>
+    ALWAYS_INLINE size_t KAutoObjectWithListContainer<T>::GetOwnedCountChecked(const KProcess *owner) {
+        return this->GetOwnedCountImpl<T>(owner, impl::GetTrueObjectContainerList<T>(m_dummy_object_list));
+    }
+
+    inline u64 KAutoObjectWithList::GetId() const {
+        #define CLASS_TOKEN_HANDLER(CLASSNAME)                                                                      \
+            if constexpr (impl::IsAutoObjectWithSpecializedGetId<CLASSNAME>) {                                      \
+                if (const CLASSNAME * const derived = this->DynamicCast<const CLASSNAME *>(); derived != nullptr) { \
+                    return []<typename T>(const T * const t_derived) ALWAYS_INLINE_LAMBDA -> u64 {                  \
+                        static_assert(std::same_as<T, CLASSNAME>);                                                  \
+                        if constexpr (impl::IsAutoObjectWithSpecializedGetId<CLASSNAME>) {                          \
+                            return impl::AutoObjectWithListComparator<CLASSNAME>::GetRedBlackKey(*t_derived);       \
+                        } else {                                                                                    \
+                            AMS_ASSUME(false);                                                                      \
+                        }                                                                                           \
+                    }(derived);                                                                                     \
+                }                                                                                                   \
+            }
+
+        FOR_EACH_K_CLASS_TOKEN_OBJECT_TYPE(CLASS_TOKEN_HANDLER)
+        #undef CLASS_TOKEN_HANDLER
+
+        return impl::AutoObjectWithListComparator<KAutoObjectWithList>::GetRedBlackKey(*this);
+    }
+
+}

libraries/libmesosphere/include/mesosphere/kern_k_class_token.hpp

@@ -21,6 +21,35 @@ namespace ams::kern {
 
     class KAutoObject;
 
+    #define FOR_EACH_K_CLASS_TOKEN_OBJECT_TYPE(HANDLER) \
+                HANDLER(KAutoObject)                    \
+                                                        \
+                HANDLER(KSynchronizationObject)         \
+                HANDLER(KReadableEvent)                 \
+                                                        \
+                HANDLER(KInterruptEvent)                \
+                HANDLER(KDebug)                         \
+                HANDLER(KThread)                        \
+                HANDLER(KServerPort)                    \
+                HANDLER(KServerSession)                 \
+                HANDLER(KClientPort)                    \
+                HANDLER(KClientSession)                 \
+                HANDLER(KProcess)                       \
+                HANDLER(KResourceLimit)                 \
+                HANDLER(KLightSession)                  \
+                HANDLER(KPort)                          \
+                HANDLER(KSession)                       \
+                HANDLER(KSharedMemory)                  \
+                HANDLER(KEvent)                         \
+                HANDLER(KLightClientSession)            \
+                HANDLER(KLightServerSession)            \
+                HANDLER(KTransferMemory)                \
+                HANDLER(KDeviceAddressSpace)            \
+                HANDLER(KSessionRequest)                \
+                HANDLER(KCodeMemory)                    \
+                HANDLER(KIoPool)                        \
+                HANDLER(KIoRegion)
+
     class KClassTokenGenerator {
         public:
             using TokenBaseType = u16;
@@ -113,8 +142,11 @@ namespace ams::kern {
                 KIoPool,
                 KIoRegion,
 
+                FinalClassesLast,
+
                 FinalClassesEnd = FinalClassesStart + NumFinalClasses,
             };
+            static_assert(ObjectType::FinalClassesLast <= ObjectType::FinalClassesEnd);
 
             template<typename T>
             static constexpr inline TokenBaseType ClassToken = GetClassToken<T>();
@@ -125,4 +157,37 @@ namespace ams::kern {
     template<typename T>
     static constexpr inline ClassTokenType ClassToken = KClassTokenGenerator::ClassToken<T>;
 
+    namespace impl {
+
+        consteval bool IsKClassTokenGeneratorForEachMacroValid() {
+            auto IsObjectTypeIncludedByMacro = [](KClassTokenGenerator::ObjectType object_type) -> bool {
+                #define CLASS_TOKEN_HANDLER(CLASSNAME) if (object_type == KClassTokenGenerator::ObjectType::CLASSNAME) { return true; }
+                FOR_EACH_K_CLASS_TOKEN_OBJECT_TYPE(CLASS_TOKEN_HANDLER)
+                #undef CLASS_TOKEN_HANDLER
+                return false;
+            };
+
+            if (!IsObjectTypeIncludedByMacro(KClassTokenGenerator::ObjectType::KAutoObject)) {
+                return false;
+            }
+
+            for (auto base = util::ToUnderlying(KClassTokenGenerator::ObjectType::BaseClassesStart); base < util::ToUnderlying(KClassTokenGenerator::ObjectType::BaseClassesEnd); ++base) {
+                if (!IsObjectTypeIncludedByMacro(static_cast<KClassTokenGenerator::ObjectType>(base))) {
+                    return false;
+                }
+            }
+
+            for (auto fin = util::ToUnderlying(KClassTokenGenerator::ObjectType::FinalClassesStart); fin < util::ToUnderlying(KClassTokenGenerator::ObjectType::FinalClassesLast); ++fin) {
+                if (!IsObjectTypeIncludedByMacro(static_cast<KClassTokenGenerator::ObjectType>(fin))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        static_assert(IsKClassTokenGeneratorForEachMacroValid());
+
+    }
+
 }

libraries/libmesosphere/include/mesosphere/kern_k_process.hpp

@@ -390,7 +390,8 @@ namespace ams::kern {
 
             void Finalize();
 
-            virtual u64 GetId() const override final { return this->GetProcessId(); }
+            ALWAYS_INLINE u64 GetIdImpl() const { return this->GetProcessId(); }
+            ALWAYS_INLINE u64 GetId() const { return this->GetIdImpl(); }
 
             virtual bool IsSignaled() const override {
                 MESOSPHERE_ASSERT_THIS();

libraries/libmesosphere/include/mesosphere/kern_k_thread.hpp

@@ -610,7 +610,8 @@ namespace ams::kern {
             size_t GetKernelStackUsage() const;
         public:
             /* Overridden parent functions. */
-            virtual u64 GetId() const override final { return this->GetThreadId(); }
+            ALWAYS_INLINE u64 GetIdImpl() const { return this->GetThreadId(); }
+            ALWAYS_INLINE u64 GetId() const { return this->GetIdImpl(); }
 
             bool IsInitialized() const { return m_initialized; }
             uintptr_t GetPostDestroyArgument() const { return reinterpret_cast<uintptr_t>(m_parent) | (m_resource_limit_release_hint ? 1 : 0); }
@@ -664,16 +665,6 @@ namespace ams::kern {
         return GetCurrentThread().GetCurrentCore();
     }
 
-    ALWAYS_INLINE void KAutoObject::ScheduleDestruction() {
-        MESOSPHERE_ASSERT_THIS();
-
-        /* Set our object to destroy. */
-        m_next_closed_object = GetCurrentThread().GetClosedObject();
-
-        /* Set ourselves as the thread's next object to destroy. */
-        GetCurrentThread().SetClosedObject(this);
-    }
-
     ALWAYS_INLINE void KTimerTask::OnTimer() {
         static_cast<KThread *>(this)->OnTimer();
     }

libraries/libmesosphere/include/mesosphere/kern_slab_helpers.hpp

@@ -68,7 +68,7 @@ namespace ams::kern {
     class KAutoObjectWithSlabHeapAndContainer : public Base {
         private:
             static constinit inline KSlabHeap<Derived, SupportDynamicExpansion> s_slab_heap;
-            static constinit inline KAutoObjectWithListContainer s_container;
+            static constinit inline KAutoObjectWithListContainer<Derived> s_container;
         private:
             static ALWAYS_INLINE Derived *Allocate() {
                 return s_slab_heap.Allocate();
@@ -78,9 +78,9 @@ namespace ams::kern {
                 s_slab_heap.Free(obj);
             }
         public:
-            class ListAccessor : public KAutoObjectWithListContainer::ListAccessor {
+            class ListAccessor : public KAutoObjectWithListContainer<Derived>::ListAccessor {
                 public:
-                    ALWAYS_INLINE ListAccessor() : KAutoObjectWithListContainer::ListAccessor(s_container) { /* ... */ }
+                    ALWAYS_INLINE ListAccessor() : KAutoObjectWithListContainer<Derived>::ListAccessor(s_container) { /* ... */ }
                     ALWAYS_INLINE ~ListAccessor() { /* ... */ }
             };
         private:
@@ -111,7 +111,7 @@ namespace ams::kern {
                 Derived * const derived = static_cast<Derived *>(this);
 
                 if (IsInitialized(derived)) {
-                    s_container.Unregister(this);
+                    s_container.Unregister(derived);
                     const uintptr_t arg = GetPostDestroyArgument(derived);
                     derived->Finalize();
                     Free(derived);