git subrepo push libraries

subrepo:
  subdir:   "libraries"
  merged:   "c4d0335b7"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "c4d0335b7"
git-subrepo:
  version:  "0.4.1"
  origin:   "???"
  commit:   "???"

docs/changelog.md

@@ -1,4 +1,14 @@
 # Changelog
+## 1.2.5
++ Support was added for 13.2.0.
++ A number of minor issues were fixed and improvements were made, including:
+  + A bug was fixed that caused `mesosphère` to underreport the total memory size by 8MB for certain games which use newer system-resource-size memory management.
+    + This caused FIFA 19 to crash, and possibly other issues.
+  + Memory management changes were made to `sm` that save 0x5000 of memory.
+  + A microoptimization was made to the way `mesosphère` manages updating the debug register for hardware single-step support.
+  + Support was fixed for enabling `usb!usb30_force_enabled` on 13.0.0+.
+  + The work-in-progress unit testing framework was updated to use doctest instead of catch2.
++ General system stability improvements to enhance the user's experience.
 ## 1.2.4
 + Changes were made to the way fs.mitm builds images when providing a layeredfs romfs.
   + Cache management (to avoid unnecessary rebuild) was revised, to add a grace period of ~500ms-1s between process closing romfs image and ams.mitm needing to rebuild if romfs is re-opened.

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = ff288336126aeda0444508e1af1f86c5f977c0f1
-	parent = 47218f0da8c9213e6faa83ad38d63f6a00d5aff7
+	commit = c4d0335b79da7207b49abf1988f45b0168b692f0
+	parent = 96631d8225611b2b490ec1e8b5a84c1b0e53157a
 	method = merge
 	cmdver = 0.4.1

libraries/libmesosphere/include/mesosphere/kern_k_scheduler.hpp

@@ -62,8 +62,7 @@ namespace ams::kern {
             KThread *m_idle_thread;
             util::Atomic<KThread *> m_current_thread;
         public:
-            constexpr KScheduler() : m_state(), m_is_active(false), m_core_id(0), m_last_context_switch_time(0), m_idle_thread(nullptr), m_current_thread(nullptr)
-            {
+            constexpr KScheduler() : m_state(), m_is_active(false), m_core_id(0), m_last_context_switch_time(0), m_idle_thread(nullptr), m_current_thread(nullptr) {
                 m_state.needs_scheduling        = true;
                 m_state.interrupt_task_runnable = false;
                 m_state.should_count_idle       = false;

libraries/libmesosphere/source/arch/arm64/svc/kern_svc_tables.cpp

@@ -59,7 +59,7 @@ namespace ams::kern::svc {
 
         /* Set omit-frame-pointer to prevent GCC from emitting MOV X29, SP instructions. */
         #pragma GCC push_options
-        #pragma GCC optimize ("-O2")
+        #pragma GCC optimize ("-O3")
         #pragma GCC optimize ("omit-frame-pointer")
 
             AMS_SVC_FOREACH_KERN_DEFINITION(DECLARE_SVC_STRUCT, _)

libraries/libmesosphere/source/board/nintendo/nx/kern_k_device_page_table.cpp

@@ -548,11 +548,11 @@ namespace ams::kern::board::nintendo::nx {
 
                         /* Print the interrupt. */
                         {
-                            constexpr auto GetBits = [] ALWAYS_INLINE_LAMBDA (u32 value, size_t ofs, size_t count) {
+                            constexpr auto GetBits = [](u32 value, size_t ofs, size_t count) ALWAYS_INLINE_LAMBDA {
                                 return (value >> ofs) & ((1u << count) - 1);
                             };
 
-                            constexpr auto GetBit = [GetBits] ALWAYS_INLINE_LAMBDA (u32 value, size_t ofs) {
+                            constexpr auto GetBit = [GetBits](u32 value, size_t ofs) ALWAYS_INLINE_LAMBDA {
                                 return (value >> ofs) & 1u;
                             };
 

libraries/libmesosphere/source/board/nintendo/nx/kern_k_system_control.cpp

@@ -312,7 +312,7 @@ namespace ams::kern::board::nintendo::nx {
 
     size_t KSystemControl::Init::GetApplicationPoolSize() {
         /* Get the base pool size. */
-        const size_t base_pool_size = [] ALWAYS_INLINE_LAMBDA () -> size_t {
+        const size_t base_pool_size = []() ALWAYS_INLINE_LAMBDA -> size_t {
             switch (GetMemoryArrangeForInit()) {
                 case smc::MemoryArrangement_4GB:
                 default:
@@ -336,7 +336,7 @@ namespace ams::kern::board::nintendo::nx {
 
     size_t KSystemControl::Init::GetAppletPoolSize() {
         /* Get the base pool size. */
-        const size_t base_pool_size = [] ALWAYS_INLINE_LAMBDA () -> size_t {
+        const size_t base_pool_size = []() ALWAYS_INLINE_LAMBDA -> size_t {
             switch (GetMemoryArrangeForInit()) {
                 case smc::MemoryArrangement_4GB:
                 default:
@@ -490,7 +490,7 @@ namespace ams::kern::board::nintendo::nx {
 
 
         if (AMS_LIKELY(s_initialized_random_generator)) {
-            return KSystemControlBase::GenerateUniformRange(min, max, [] ALWAYS_INLINE_LAMBDA () -> u64 { return s_random_generator.GenerateRandomU64(); });
+            return KSystemControlBase::GenerateUniformRange(min, max, []() ALWAYS_INLINE_LAMBDA -> u64 { return s_random_generator.GenerateRandomU64(); });
         } else {
             return KSystemControlBase::GenerateUniformRange(min, max, GenerateRandomU64FromSmc);
         }
@@ -680,4 +680,4 @@ namespace ams::kern::board::nintendo::nx {
         Kernel::GetMemoryManager().Close(KPageTable::GetHeapPhysicalAddress(address), size / PageSize);
     }
 
-}
+}

libraries/libmesosphere/source/kern_k_memory_layout.board.nintendo_nx.cpp

@@ -195,7 +195,7 @@ namespace ams::kern {
                 static_assert(KMemoryManager::Pool_Secure == KMemoryManager::Pool_System);
 
                 /* Get Secure pool size. */
-                const size_t secure_pool_size = [] ALWAYS_INLINE_LAMBDA (auto target_firmware) -> size_t {
+                const size_t secure_pool_size = [](auto target_firmware) ALWAYS_INLINE_LAMBDA -> size_t {
                     constexpr size_t LegacySecureKernelSize = 8_MB;          /* KPageBuffer pages, other small kernel allocations. */
                     constexpr size_t LegacySecureMiscSize   = 1_MB;          /* Miscellaneous pages for secure process mapping. */
                     constexpr size_t LegacySecureHeapSize   = 24_MB;         /* Heap pages for secure process mapping (fs). */
@@ -274,4 +274,4 @@ namespace ams::kern {
 
     }
 
-}
+}

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -2398,7 +2398,7 @@ namespace ams::kern {
         size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
         size_t tot_size = cur_size;
 
-        auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+        auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
             /* Ensure the address is linear mapped. */
             R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 
@@ -2484,7 +2484,7 @@ namespace ams::kern {
         size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
         size_t tot_size = cur_size;
 
-        auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+        auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
             /* Ensure the address is linear mapped. */
             R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 
@@ -2943,7 +2943,7 @@ namespace ams::kern {
             size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
             size_t tot_size = cur_size;
 
-            auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+            auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
                 /* Ensure the address is linear mapped. */
                 R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 
@@ -3023,7 +3023,7 @@ namespace ams::kern {
             size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
             size_t tot_size = cur_size;
 
-            auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+            auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
                 /* Ensure the address is linear mapped. */
                 R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 
@@ -3092,7 +3092,7 @@ namespace ams::kern {
             size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
             size_t tot_size = cur_size;
 
-            auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+            auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
                 /* Ensure the address is linear mapped. */
                 R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 
@@ -3172,7 +3172,7 @@ namespace ams::kern {
             size_t cur_size = next_entry.block_size - (GetInteger(cur_addr) & (next_entry.block_size - 1));
             size_t tot_size = cur_size;
 
-            auto PerformCopy = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+            auto PerformCopy = [&]() ALWAYS_INLINE_LAMBDA -> Result {
                 /* Ensure the address is linear mapped. */
                 R_UNLESS(IsLinearMappedPhysicalAddress(cur_addr), svc::ResultInvalidCurrentMemory());
 

libraries/libmesosphere/source/kern_k_process.cpp

@@ -893,7 +893,7 @@ namespace ams::kern {
     size_t KProcess::GetTotalUserPhysicalMemorySize() const {
         /* Get the amount of free and used size. */
         const size_t free_size = m_resource_limit->GetFreeValue(ams::svc::LimitableResource_PhysicalMemoryMax);
-        const size_t used_size = this->GetUsedNonSystemUserPhysicalMemorySize();
+        const size_t used_size = this->GetUsedUserPhysicalMemorySize();
         const size_t max_size  = m_max_process_memory;
 
         if (used_size + free_size > max_size) {

libraries/libmesosphere/source/kern_k_scheduler.cpp

@@ -15,10 +15,10 @@
  */
 #include <mesosphere.hpp>
 
-namespace ams::kern {
+#pragma GCC push_options
+#pragma GCC optimize ("-O3")
 
-    #pragma GCC push_options
-    #pragma GCC optimize ("-O3")
+namespace ams::kern {
 
     bool KScheduler::s_scheduler_update_needed;
     KScheduler::LockType KScheduler::s_scheduler_lock;
@@ -249,22 +249,18 @@ namespace ams::kern {
 
         #if defined(MESOSPHERE_ENABLE_HARDWARE_SINGLE_STEP)
         /* Ensure the single-step bit in mdscr reflects the correct single-step state for the new thread. */
+        /* NOTE: Per ARM docs, changing the single-step bit requires a "context synchronization event" to */
+        /* be sure that our new configuration takes. However, there are three types of synchronization event: */
+        /* Taking an exception, returning from an exception, and ISB. The single-step bit change only matters */
+        /* in EL0...which implies a return-from-exception has occurred since we set the bit. Thus, forcing */
+        /* an ISB is unnecessary, and we can modify the register safely and be confident it will affect the next */
+        /* userland instruction executed. */
         cpu::MonitorDebugSystemControlRegisterAccessor().SetSoftwareStep(next_thread->IsSingleStep()).Store();
         #endif
 
         /* Switch the current process, if we're switching processes. */
         if (KProcess *next_process = next_thread->GetOwnerProcess(); next_process != cur_process) {
             KProcess::Switch(cur_process, next_process);
-        } else {
-            /* The single-step bit set up above requires an instruction synchronization barrier, to ensure */
-            /* the state change takes before we actually perform a return which might break-to-step. */
-            /* KProcess::Switch performs an isb incidentally, and so when we're changing process we */
-            /* can piggy-back off of that isb to avoid unnecessarily emptying the pipeline twice. */
-            /* However, this means that when we're switching to thread in a different process, */
-            /* we must ensure that we still isb. In practice, gcc will deduplicate into a single isb. */
-            #if defined(MESOSPHERE_ENABLE_HARDWARE_SINGLE_STEP)
-            cpu::InstructionMemoryBarrier();
-            #endif
         }
 
         /* Set the new thread. */
@@ -602,6 +598,6 @@ namespace ams::kern {
         }
     }
 
-    #pragma GCC pop_options
-
 }
+
+#pragma GCC pop_options

libraries/libmesosphere/source/kern_k_server_session.cpp

@@ -15,10 +15,10 @@
  */
 #include <mesosphere.hpp>
 
-namespace ams::kern {
+#pragma GCC push_options
+#pragma GCC optimize ("-O3")
 
-    #pragma GCC push_options
-    #pragma GCC optimize ("-O3")
+namespace ams::kern {
 
     namespace ipc {
 
@@ -1385,8 +1385,6 @@ namespace ams::kern {
         this->NotifyAvailable(svc::ResultSessionClosed());
     }
 
-    #pragma GCC pop_options
-
     void KServerSession::Dump() {
         MESOSPHERE_ASSERT_THIS();
 
@@ -1420,3 +1418,5 @@ namespace ams::kern {
     }
 
 }
+
+#pragma GCC pop_options

libraries/libmesosphere/source/kern_k_system_control_base.cpp

@@ -96,7 +96,7 @@ namespace ams::kern {
             s_initialized_random_generator = true;
         }
 
-        return KSystemControlBase::GenerateUniformRange(min, max, [] ALWAYS_INLINE_LAMBDA () -> u64 { return s_random_generator.GenerateRandomU64(); });
+        return KSystemControlBase::GenerateUniformRange(min, max, []() ALWAYS_INLINE_LAMBDA -> u64 { return s_random_generator.GenerateRandomU64(); });
     }
 
     /* System Initialization. */
@@ -194,7 +194,7 @@ namespace ams::kern {
         KScopedInterruptDisable intr_disable;
         KScopedSpinLock lk(s_random_lock);
 
-        return KSystemControlBase::GenerateUniformRange(min, max, [] ALWAYS_INLINE_LAMBDA () -> u64 { return s_random_generator.GenerateRandomU64(); });
+        return KSystemControlBase::GenerateUniformRange(min, max, []() ALWAYS_INLINE_LAMBDA -> u64 { return s_random_generator.GenerateRandomU64(); });
     }
 
     u64 KSystemControlBase::GenerateRandomU64() {
@@ -292,4 +292,4 @@ namespace ams::kern {
         Kernel::GetMemoryManager().Close(KPageTable::GetHeapPhysicalAddress(address), size / PageSize);
     }
 
-}
+}

libraries/libmesosphere/source/kern_k_thread.cpp

@@ -1183,7 +1183,7 @@ namespace ams::kern {
         KScopedSchedulerLock sl;
 
         /* Determine if this is the first termination request. */
-        const bool first_request = [&] ALWAYS_INLINE_LAMBDA () -> bool {
+        const bool first_request = [&]() ALWAYS_INLINE_LAMBDA -> bool {
             /* Perform an atomic compare-and-swap from false to true. */
             bool expected = false;
             return m_termination_requested.CompareExchangeStrong(expected, true);

libraries/libmesosphere/source/svc/kern_svc_address_translation.cpp

@@ -48,7 +48,7 @@ namespace ams::kern::svc {
             /* Check whether the address is aligned. */
             const bool aligned = util::IsAligned(phys_addr, PageSize);
 
-            auto QueryIoMappingFromPageTable = [&] ALWAYS_INLINE_LAMBDA (uint64_t phys_addr, size_t size) -> Result {
+            auto QueryIoMappingFromPageTable = [&](uint64_t phys_addr, size_t size) ALWAYS_INLINE_LAMBDA -> Result {
                 /* The size must be non-zero. */
                 R_UNLESS(size > 0, svc::ResultInvalidSize());
 

libraries/libmesosphere/source/svc/kern_svc_ipc.cpp

@@ -15,10 +15,10 @@
  */
 #include <mesosphere.hpp>
 
-namespace ams::kern::svc {
+#pragma GCC push_options
+#pragma GCC optimize ("-O3")
 
-    #pragma GCC push_options
-    #pragma GCC optimize ("-O3")
+namespace ams::kern::svc {
 
     /* =============================    Common    ============================= */
 
@@ -315,6 +315,6 @@ namespace ams::kern::svc {
         return ReplyAndReceiveWithUserBuffer(out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
     }
 
-    #pragma GCC pop_options
-
 }
+
+#pragma GCC pop_options

libraries/libmesosphere/source/svc/kern_svc_process.cpp

@@ -210,7 +210,7 @@ namespace ams::kern::svc {
             KResourceLimit *process_resource_limit = resource_limit.IsNotNull() ? resource_limit.GetPointerUnsafe() : std::addressof(Kernel::GetSystemResourceLimit());
 
             /* Get the pool for the process. */
-            const auto pool = [] ALWAYS_INLINE_LAMBDA (u32 flags) -> KMemoryManager::Pool {
+            const auto pool = [](u32 flags) ALWAYS_INLINE_LAMBDA -> KMemoryManager::Pool {
                 if (GetTargetFirmware() >= TargetFirmware_5_0_0) {
                     switch (flags & ams::svc::CreateProcessFlag_PoolPartitionMask) {
                         case ams::svc::CreateProcessFlag_PoolPartitionApplication:

libraries/libstratosphere/include/stratosphere/hos/hos_types.hpp

@@ -66,6 +66,8 @@ namespace ams::hos {
         Version_12_0_3  = ::ams::TargetFirmware_12_0_3,
         Version_12_1_0  = ::ams::TargetFirmware_12_1_0,
         Version_13_0_0  = ::ams::TargetFirmware_13_0_0,
+        Version_13_1_0  = ::ams::TargetFirmware_13_1_0,
+        Version_13_2_0  = ::ams::TargetFirmware_13_2_0,
 
         Version_Current = ::ams::TargetFirmware_Current,
 

libraries/libstratosphere/include/stratosphere/settings/settings_types.hpp

@@ -62,20 +62,16 @@ namespace ams::settings {
 
         char name[MaxLength];
 
-        static constexpr LanguageCode Encode(const char *name, size_t name_size) {
+        static constexpr LanguageCode Encode(util::string_view name) {
             LanguageCode out{};
-            for (size_t i = 0; i < MaxLength && i < name_size; i++) {
+            for (size_t i = 0; i < MaxLength && i < name.size(); i++) {
                 out.name[i] = name[i];
             }
             return out;
         }
 
-        static constexpr LanguageCode Encode(const char *name) {
-            return Encode(name, std::strlen(name));
-        }
-
         template<Language Lang>
-        static constexpr inline LanguageCode EncodeLanguage = [] {
+        static constexpr inline LanguageCode EncodeLanguage() {
             if constexpr (false) { /* ... */ }
             #define AMS_MATCH_LANGUAGE(lang, enc) else if constexpr (Lang == Language_##lang) { return LanguageCode::Encode(enc); }
             AMS_MATCH_LANGUAGE(Japanese,                "ja")
@@ -98,28 +94,28 @@ namespace ams::settings {
             AMS_MATCH_LANGUAGE(TraditionalChinese,      "zh-Hant")
             #undef AMS_MATCH_LANGUAGE
             else { static_assert(Lang != Language_Japanese); }
-        }();
+        }
 
         static constexpr inline LanguageCode Encode(const Language language) {
             constexpr LanguageCode EncodedLanguages[Language_Count] = {
-                EncodeLanguage<Language_Japanese>,
-                EncodeLanguage<Language_AmericanEnglish>,
-                EncodeLanguage<Language_French>,
-                EncodeLanguage<Language_German>,
-                EncodeLanguage<Language_Italian>,
-                EncodeLanguage<Language_Spanish>,
-                EncodeLanguage<Language_Chinese>,
-                EncodeLanguage<Language_Korean>,
-                EncodeLanguage<Language_Dutch>,
-                EncodeLanguage<Language_Portuguese>,
-                EncodeLanguage<Language_Russian>,
-                EncodeLanguage<Language_Taiwanese>,
-                EncodeLanguage<Language_BritishEnglish>,
-                EncodeLanguage<Language_CanadianFrench>,
-                EncodeLanguage<Language_LatinAmericanSpanish>,
+                EncodeLanguage<Language_Japanese>(),
+                EncodeLanguage<Language_AmericanEnglish>(),
+                EncodeLanguage<Language_French>(),
+                EncodeLanguage<Language_German>(),
+                EncodeLanguage<Language_Italian>(),
+                EncodeLanguage<Language_Spanish>(),
+                EncodeLanguage<Language_Chinese>(),
+                EncodeLanguage<Language_Korean>(),
+                EncodeLanguage<Language_Dutch>(),
+                EncodeLanguage<Language_Portuguese>(),
+                EncodeLanguage<Language_Russian>(),
+                EncodeLanguage<Language_Taiwanese>(),
+                EncodeLanguage<Language_BritishEnglish>(),
+                EncodeLanguage<Language_CanadianFrench>(),
+                EncodeLanguage<Language_LatinAmericanSpanish>(),
                 /* 4.0.0+ */
-                EncodeLanguage<Language_SimplifiedChinese>,
-                EncodeLanguage<Language_TraditionalChinese>,
+                EncodeLanguage<Language_SimplifiedChinese>(),
+                EncodeLanguage<Language_TraditionalChinese>(),
             };
             return EncodedLanguages[language];
         }

libraries/libstratosphere/include/stratosphere/sf/cmif/sf_cmif_domain_manager.hpp

@@ -54,11 +54,11 @@ namespace ams::sf::cmif {
 
                     void DisposeImpl();
 
-                    virtual void AddReference() {
+                    virtual void AddReference() override {
                         ServiceObjectImplBase2::AddReferenceImpl();
                     }
 
-                    virtual void Release() {
+                    virtual void Release() override {
                         if (ServiceObjectImplBase2::ReleaseImpl()) {
                             this->DisposeImpl();
                         }

libraries/libstratosphere/include/stratosphere/sf/sf_lmem_utility.hpp

@@ -43,7 +43,7 @@ namespace ams::sf {
                 return lmem::FreeToExpHeap(m_handle, buffer);
             }
 
-            virtual bool IsEqualImpl(const MemoryResource &resource) const {
+            virtual bool IsEqualImpl(const MemoryResource &resource) const override {
                 return this == std::addressof(resource);
             }
     };
@@ -76,9 +76,9 @@ namespace ams::sf {
                 return lmem::FreeToUnitHeap(m_handle, buffer);
             }
 
-            virtual bool IsEqualImpl(const MemoryResource &resource) const {
+            virtual bool IsEqualImpl(const MemoryResource &resource) const override {
                 return this == std::addressof(resource);
             }
     };
 
-}
+}

libraries/libstratosphere/include/stratosphere/sf/sf_mem_utility.hpp

@@ -37,9 +37,9 @@ namespace ams::sf {
                 return m_standard_allocator->Free(buffer);
             }
 
-            virtual bool IsEqualImpl(const MemoryResource &resource) const {
+            virtual bool IsEqualImpl(const MemoryResource &resource) const override {
                 return this == std::addressof(resource);
             }
     };
 
-}
+}

libraries/libstratosphere/include/stratosphere/sf/sf_object_impl_factory.hpp

@@ -31,7 +31,7 @@ namespace ams::sf {
             public:
                 class Object;
                 using Allocator = StatelessDummyAllocator;
-                using StatelessAllocator = typename Policy::StatelessAllocator<Object>;
+                using StatelessAllocator = typename Policy::template StatelessAllocator<Object>;
 
                 class Object final : private ::ams::sf::impl::ServiceObjectImplBase2, public Base {
                     NON_COPYABLE(Object);

libraries/libstratosphere/include/stratosphere/sm/sm_types.hpp

@@ -40,8 +40,8 @@ namespace ams::sm {
             return out;
         }
 
-        static constexpr ServiceName Encode(const char *name) {
-            return Encode(name, std::strlen(name));
+        static constexpr ServiceName Encode(util::string_view name) {
+            return Encode(name.data(), name.size());
         }
     };
 

libraries/libstratosphere/include/stratosphere/time/time_calendar_time.hpp

@@ -50,7 +50,7 @@ namespace ams::time {
                 AMS_ASSERT(rhs.IsValid());
             }
 
-            constexpr auto ToUint64 = [] ALWAYS_INLINE_LAMBDA (const time::CalendarTime &time) {
+            constexpr auto ToUint64 = [](const time::CalendarTime &time) ALWAYS_INLINE_LAMBDA {
                 return (static_cast<u64>(time.year)   << 40) |
                        (static_cast<u64>(time.month)  << 32) |
                        (static_cast<u64>(time.day)    << 24) |

libraries/libstratosphere/include/stratosphere/tipc/impl/tipc_autogen_interface_macros.hpp

@@ -40,12 +40,28 @@ namespace ams::tipc::impl {
     #define AMS_TIPC_IMPL_EXTRACT_SYNC_METHOD_ARGUMENTS(CLASSNAME, CMD_ID, RETURN, NAME, ARGS, ARGNAMES, VERSION_MIN, VERSION_MAX) \
         using NAME##ArgumentsType = ::ams::tipc::impl::SyncFunctionArgsType<&NAME##ArgumentsFunctionHolder::f>;
 
+    #define AMS_TIPC_IMPL_GET_MAXIMUM_REQUEST_SIZE(CLASSNAME, CMD_ID, RETURN, NAME, ARGS, ARGNAMES, VERSION_MIN, VERSION_MAX) \
+        , ::ams::tipc::impl::CommandMetaInfo<CMD_ID + 0x10, NAME##ArgumentsType>::InMessageTotalSize
+
+    #define AMS_TIPC_IMPL_GET_MAXIMUM_RESPONSE_SIZE(CLASSNAME, CMD_ID, RETURN, NAME, ARGS, ARGNAMES, VERSION_MIN, VERSION_MAX) \
+        , ::ams::tipc::impl::CommandMetaInfo<CMD_ID + 0x10, NAME##ArgumentsType>::OutMessageTotalSize
+
     #define AMS_TIPC_IMPL_DEFINE_INTERFACE(BASECLASS, CLASSNAME, CMD_MACRO)       \
         class CLASSNAME : public BASECLASS {                                      \
             private:                                                              \
                 CMD_MACRO(CLASSNAME, AMS_TIPC_IMPL_DEFINE_SYNC_METHOD_HOLDER)     \
             public:                                                               \
                 CMD_MACRO(CLASSNAME, AMS_TIPC_IMPL_EXTRACT_SYNC_METHOD_ARGUMENTS) \
+            public:                                                               \
+                static constexpr size_t MaximumRequestSize = std::max<size_t>({   \
+                    0                                                             \
+                    CMD_MACRO(CLASSNAME, AMS_TIPC_IMPL_GET_MAXIMUM_REQUEST_SIZE)  \
+                });                                                               \
+                                                                                  \
+                static constexpr size_t MaximumResponseSize = std::max<size_t>({  \
+                    0                                                             \
+                    CMD_MACRO(CLASSNAME, AMS_TIPC_IMPL_GET_MAXIMUM_RESPONSE_SIZE) \
+                });                                                               \
         };
 
     #define AMS_TIPC_IMPL_DEFINE_CONCEPT_HELPERS(CLASSNAME, CMD_ID, RETURN, NAME, ARGS, ARGNAMES, VERSION_MIN, VERSION_MAX)               \

libraries/libstratosphere/include/stratosphere/tipc/impl/tipc_impl_command_serialization.hpp

@@ -319,6 +319,9 @@ namespace ams::tipc::impl {
             static constexpr auto OutMessageResultIndex  = svc::ipc::MessageBuffer::GetRawDataIndex(OutMessageHeader, OutSpecialHeader);
             static constexpr auto OutMessageRawDataIndex = OutMessageResultIndex + 1;
 
+            static constexpr size_t InMessageTotalSize  = (InMessageRawDataIndex  * sizeof(u32)) + InDataSize;
+            static constexpr size_t OutMessageTotalSize = (OutMessageRawDataIndex * sizeof(u32)) + OutDataSize;
+
         /* Construction of argument serialization structs. */
         private:
             template<typename>
@@ -472,7 +475,7 @@ namespace ams::tipc::impl {
             using OutRawHolderType      = OutRawHolder<CommandMeta::OutDataSize, CommandMeta::OutDataAlign, CommandMeta::OutMessageRawDataIndex>;
             using OutHandleHolderType   = OutHandleHolder<CommandMeta::NumOutMoveHandles, CommandMeta::NumOutCopyHandles, CommandMeta::OutMessageHandleIndex>;
         private:
-            static consteval u64 GetMessageHeaderForCheck(const svc::ipc::MessageBuffer::MessageHeader &header) {
+            static constexpr u64 GetMessageHeaderForCheck(const svc::ipc::MessageBuffer::MessageHeader &header) {
                 using Value = util::BitPack32::Field<0, BITSIZEOF(util::BitPack32)>;
 
                 const util::BitPack32 *data = header.GetData();
@@ -482,7 +485,7 @@ namespace ams::tipc::impl {
                 return static_cast<u64>(lower) | (static_cast<u64>(upper) << BITSIZEOF(u32));
             }
 
-            static consteval u32 GetSpecialHeaderForCheck(const svc::ipc::MessageBuffer::SpecialHeader &header) {
+            static constexpr u32 GetSpecialHeaderForCheck(const svc::ipc::MessageBuffer::SpecialHeader &header) {
                 using Value = util::BitPack32::Field<0, BITSIZEOF(util::BitPack32)>;
 
                 return header.GetHeader()->Get<Value>();

libraries/libstratosphere/include/stratosphere/tipc/tipc_deferral_manager.hpp

@@ -44,16 +44,17 @@ namespace ams::tipc {
 
     }
 
-    class DeferrableBase : public impl::DeferrableBaseTag {
+    class DeferrableBaseImpl : public impl::DeferrableBaseTag {
         private:
             DeferralManagerBase *m_deferral_manager;
             ObjectHolder m_object_holder;
             uintptr_t m_resume_key;
-            u8 m_message_buffer[svc::ipc::MessageBufferSize];
+            const u32 m_message_buffer_size;
+            u8 m_message_buffer_base[0];
         public:
-            ALWAYS_INLINE DeferrableBase() : m_deferral_manager(nullptr), m_object_holder(), m_resume_key() { /* ... */ }
+            ALWAYS_INLINE DeferrableBaseImpl(u32 mb_size) : m_deferral_manager(nullptr), m_object_holder(), m_resume_key(), m_message_buffer_size(mb_size) { /* ... */ }
 
-            ~DeferrableBase();
+            ~DeferrableBaseImpl();
 
             ALWAYS_INLINE void SetDeferralManager(DeferralManagerBase *manager, os::NativeHandle reply_target, ServiceObjectBase *object) {
                 m_deferral_manager = manager;
@@ -67,7 +68,7 @@ namespace ams::tipc {
             template<IsResumeKey ResumeKey>
             ALWAYS_INLINE void RegisterRetry(ResumeKey key) {
                 m_resume_key = ConvertToInternalResumeKey(key);
-                std::memcpy(m_message_buffer, svc::ipc::GetMessageBuffer(), sizeof(m_message_buffer));
+                std::memcpy(m_message_buffer_base, svc::ipc::GetMessageBuffer(), m_message_buffer_size);
             }
 
             template<IsResumeKey ResumeKey, typename F>
@@ -85,11 +86,49 @@ namespace ams::tipc {
                 m_resume_key = 0;
 
                 /* Restore message buffer. */
-                std::memcpy(svc::ipc::GetMessageBuffer(), m_message_buffer, sizeof(m_message_buffer));
+                std::memcpy(svc::ipc::GetMessageBuffer(), m_message_buffer_base, m_message_buffer_size);
 
                 /* Process the request. */
                 return port_manager->ProcessDeferredRequest(m_object_holder);
             }
+        protected:
+            static consteval size_t GetMessageBufferOffsetBase();
+    };
+    static_assert(std::is_standard_layout<DeferrableBaseImpl>::value);
+
+    template<size_t _MessageBufferRequiredSize>
+    class DeferrableBaseImplWithBuffer : public DeferrableBaseImpl {
+        private:
+            static constexpr size_t MessageBufferRequiredSize = _MessageBufferRequiredSize;
+        private:
+            u8 m_message_buffer[MessageBufferRequiredSize];
+        public:
+            DeferrableBaseImplWithBuffer();
+        private:
+            static consteval size_t GetMessageBufferOffset();
+    };
+
+    consteval size_t DeferrableBaseImpl::GetMessageBufferOffsetBase() {
+        return AMS_OFFSETOF(DeferrableBaseImpl, m_message_buffer_base);
+    }
+
+    template<size_t _MessageBufferRequiredSize>
+    consteval size_t DeferrableBaseImplWithBuffer<_MessageBufferRequiredSize>::GetMessageBufferOffset() {
+        return AMS_OFFSETOF(DeferrableBaseImplWithBuffer<_MessageBufferRequiredSize>, m_message_buffer);
+    }
+
+    template<size_t _MessageBufferRequiredSize>
+    ALWAYS_INLINE DeferrableBaseImplWithBuffer<_MessageBufferRequiredSize>::DeferrableBaseImplWithBuffer() : DeferrableBaseImpl(MessageBufferRequiredSize) {
+        static_assert(GetMessageBufferOffsetBase() == GetMessageBufferOffset());
+        static_assert(sizeof(DeferrableBaseImplWithBuffer<_MessageBufferRequiredSize>) >= sizeof(DeferrableBaseImpl) + MessageBufferRequiredSize);
+    }
+
+    template<typename Interface, size_t MaximumDefaultRequestSize = 0>
+    class DeferrableBase : public DeferrableBaseImplWithBuffer<std::max(Interface::MaximumRequestSize, MaximumDefaultRequestSize)> {
+        private:
+            using BaseImpl = DeferrableBaseImplWithBuffer<std::max(Interface::MaximumRequestSize, MaximumDefaultRequestSize)>;
+        public:
+            using BaseImpl::BaseImpl;
     };
 
     template<class T>
@@ -100,11 +139,11 @@ namespace ams::tipc {
         NON_MOVEABLE(DeferralManagerBase);
         private:
             size_t m_object_count;
-            DeferrableBase *m_objects_base[0];
+            DeferrableBaseImpl *m_objects_base[0];
         public:
             ALWAYS_INLINE DeferralManagerBase() : m_object_count(0) { /* ... */  }
 
-            void AddObject(DeferrableBase &object, os::NativeHandle reply_target, ServiceObjectBase *service_object) {
+            void AddObject(DeferrableBaseImpl &object, os::NativeHandle reply_target, ServiceObjectBase *service_object) {
                 /* Set ourselves as the manager for the object. */
                 object.SetDeferralManager(this, reply_target, service_object);
 
@@ -113,7 +152,7 @@ namespace ams::tipc {
                 m_objects_base[m_object_count++] = std::addressof(object);
             }
 
-            void RemoveObject(DeferrableBase *object) {
+            void RemoveObject(DeferrableBaseImpl *object) {
                 /* If the object is present, remove it. */
                 for (size_t i = 0; i < m_object_count; ++i) {
                     if (m_objects_base[i] == object) {
@@ -148,7 +187,7 @@ namespace ams::tipc {
     };
     static_assert(std::is_standard_layout<DeferralManagerBase>::value);
 
-    inline DeferrableBase::~DeferrableBase() {
+    inline DeferrableBaseImpl::~DeferrableBaseImpl() {
         AMS_ASSUME(m_deferral_manager != nullptr);
         m_deferral_manager->RemoveObject(this);
     }
@@ -156,7 +195,7 @@ namespace ams::tipc {
     template<size_t N> requires (N > 0)
     class DeferralManager final : public DeferralManagerBase {
         private:
-            DeferrableBase *m_objects[N];
+            DeferrableBaseImpl *m_objects[N];
         public:
             DeferralManager();
         private:
@@ -167,15 +206,15 @@ namespace ams::tipc {
         return AMS_OFFSETOF(DeferralManagerBase, m_objects_base);
     }
 
-    template<size_t N>
+    template<size_t N> requires (N > 0)
     consteval size_t DeferralManager<N>::GetObjectPointersOffset() {
         return AMS_OFFSETOF(DeferralManager<N>, m_objects);
     }
 
-    template<size_t N>
+    template<size_t N> requires (N > 0)
     inline DeferralManager<N>::DeferralManager() : DeferralManagerBase() {
         static_assert(GetObjectPointersOffset() == GetObjectPointersOffsetBase());
-        static_assert(sizeof(DeferralManager<N>) == sizeof(DeferralManagerBase) + N * sizeof(DeferrableBase *));
+        static_assert(sizeof(DeferralManager<N>) == sizeof(DeferralManagerBase) + N * sizeof(DeferrableBaseImpl *));
     }
 
 }

libraries/libstratosphere/include/stratosphere/tipc/tipc_server_manager.hpp

@@ -686,7 +686,7 @@ namespace ams::tipc {
                             }
 
                             /* Try to reply/receive. */
-                            const Result result = [&] ALWAYS_INLINE_LAMBDA () -> Result {
+                            const Result result = [&]() ALWAYS_INLINE_LAMBDA -> Result {
                                 os::MultiWaitHolderType *signaled_holder = nullptr;
                                 ON_SCOPE_EXIT { AMS_ABORT_UNLESS(signaled_holder == nullptr); };
                                 return m_object_manager->ReplyAndReceive(std::addressof(signaled_holder), out_object, reply_target, std::addressof(m_multi_wait));
@@ -747,7 +747,7 @@ namespace ams::tipc {
                 using PortManager = PortManagerImpl;
             private:
                 PortManager m_port_manager;
-                PortInfo::Allocator m_port_allocator;
+                typename PortInfo::Allocator m_port_allocator;
             public:
                 constexpr ServerManagerImpl() : m_port_manager(), m_port_allocator() { /* ... */ }
 

libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_state_machine.cpp

@@ -196,7 +196,7 @@ namespace ams::htclow::ctrl {
         /* Lock ourselves. */
         std::scoped_lock lk(m_mutex);
 
-        auto IsSupportedServiceChannel = [] ALWAYS_INLINE_LAMBDA (const impl::ChannelInternalType &channel, const impl::ChannelInternalType *supported, int num_supported) -> bool {
+        auto IsSupportedServiceChannel = [](const impl::ChannelInternalType &channel, const impl::ChannelInternalType *supported, int num_supported) ALWAYS_INLINE_LAMBDA -> bool {
             for (auto i = 0; i < num_supported; ++i) {
                 if (channel.module_id == supported[i].module_id && channel.channel_id == supported[i].channel_id) {
                     return true;

libraries/libstratosphere/source/ncm/ncm_content_meta_database_impl.cpp

@@ -308,7 +308,7 @@ namespace ams::ncm {
             out_orphaned[i] = true;
         }
 
-        auto IsOrphanedContent = [] ALWAYS_INLINE_LAMBDA (const sf::InArray<ContentId> &list, const ncm::ContentId &id) -> util::optional<size_t> {
+        auto IsOrphanedContent = [](const sf::InArray<ContentId> &list, const ncm::ContentId &id) ALWAYS_INLINE_LAMBDA -> util::optional<size_t> {
             /* Check if any input content ids match our found content id. */
             for (size_t i = 0; i < list.GetSize(); i++) {
                 if (list[i] == id) {

libraries/libvapours/include/vapours/ams/ams_api_version.h

@@ -17,10 +17,10 @@
 
 #define ATMOSPHERE_RELEASE_VERSION_MAJOR    1
 #define ATMOSPHERE_RELEASE_VERSION_MINOR    2
-#define ATMOSPHERE_RELEASE_VERSION_MICRO    4
+#define ATMOSPHERE_RELEASE_VERSION_MICRO    5
 
 #define ATMOSPHERE_RELEASE_VERSION ATMOSPHERE_RELEASE_VERSION_MAJOR, ATMOSPHERE_RELEASE_VERSION_MINOR, ATMOSPHERE_RELEASE_VERSION_MICRO
 
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR 13
-#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 1
+#define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR 2
 #define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO 0

libraries/libvapours/include/vapours/ams/ams_target_firmware.h

@@ -65,8 +65,9 @@
 #define ATMOSPHERE_TARGET_FIRMWARE_12_1_0 ATMOSPHERE_TARGET_FIRMWARE(12,  1,  0)
 #define ATMOSPHERE_TARGET_FIRMWARE_13_0_0 ATMOSPHERE_TARGET_FIRMWARE(13,  0,  0)
 #define ATMOSPHERE_TARGET_FIRMWARE_13_1_0 ATMOSPHERE_TARGET_FIRMWARE(13,  1,  0)
+#define ATMOSPHERE_TARGET_FIRMWARE_13_2_0 ATMOSPHERE_TARGET_FIRMWARE(13,  2,  0)
 
-#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_13_1_0
+#define ATMOSPHERE_TARGET_FIRMWARE_CURRENT ATMOSPHERE_TARGET_FIRMWARE_13_2_0
 
 #define ATMOSPHERE_TARGET_FIRMWARE_MIN ATMOSPHERE_TARGET_FIRMWARE(0, 0, 0)
 #define ATMOSPHERE_TARGET_FIRMWARE_MAX ATMOSPHERE_TARGET_FIRMWARE_CURRENT
@@ -124,6 +125,7 @@ namespace ams {
         TargetFirmware_12_1_0  = ATMOSPHERE_TARGET_FIRMWARE_12_1_0,
         TargetFirmware_13_0_0  = ATMOSPHERE_TARGET_FIRMWARE_13_0_0,
         TargetFirmware_13_1_0  = ATMOSPHERE_TARGET_FIRMWARE_13_1_0,
+        TargetFirmware_13_2_0  = ATMOSPHERE_TARGET_FIRMWARE_13_2_0,
 
         TargetFirmware_Current = ATMOSPHERE_TARGET_FIRMWARE_CURRENT,
 

libraries/libvapours/include/vapours/results/results_common.hpp

@@ -177,7 +177,11 @@ namespace ams {
                 static_assert(Value != Base::SuccessValue, "Value != Base::SuccessValue");
             public:
                 constexpr ALWAYS_INLINE operator Result() const { return MakeResult(Value); }
-                constexpr ALWAYS_INLINE operator ResultSuccess() const { OnResultAbort(Value); }
+                constexpr ALWAYS_INLINE operator ResultSuccess() const {
+                    OnResultAbort(Value);
+                    __builtin_unreachable();
+                    return ResultSuccess();
+                }
 
                 constexpr ALWAYS_INLINE bool IsSuccess() const { return false; }
                 constexpr ALWAYS_INLINE bool IsFailure() const { return !this->IsSuccess(); }

libraries/libvapours/include/vapours/util/util_intrusive_red_black_tree.hpp

@@ -295,7 +295,7 @@ namespace ams::util {
                 private:
                     constexpr explicit ALWAYS_INLINE Iterator(ImplIterator it) : m_impl(it) { /* ... */ }
 
-                    constexpr explicit ALWAYS_INLINE Iterator(ImplIterator::pointer p) : m_impl(p) { /* ... */ }
+                    constexpr explicit ALWAYS_INLINE Iterator(typename ImplIterator::pointer p) : m_impl(p) { /* ... */ }
 
                     constexpr ALWAYS_INLINE ImplIterator GetImplIterator() const {
                         return m_impl;

libraries/libvapours/include/vapours/util/util_optional.hpp

@@ -225,7 +225,7 @@ namespace ams::util {
         template<typename T, typename Derived>
         class OptionalBaseImpl {
             protected:
-                using StoredType = std::remove_const<T>::type;
+                using StoredType = std::remove_const_t<T>;
 
                 template<typename... Args>
                 constexpr void ConstructImpl(Args &&... args) { static_cast<Derived *>(this)->m_payload.Construct(std::forward<Args>(args)...); }

stratosphere/ams_mitm/source/sysupdater/sysupdater_service.cpp

@@ -152,7 +152,7 @@ namespace ams::mitm::sysupdater {
             ON_SCOPE_EXIT { std::free(data_buffer); };
 
             /* Declare helper for result validation. */
-            auto ValidateResult = [&] ALWAYS_INLINE_LAMBDA (Result result) -> Result {
+            auto ValidateResult = [&](Result result) ALWAYS_INLINE_LAMBDA -> Result {
                 *out_result = result;
                 return result;
             };

stratosphere/loader/source/ldr_embedded_usb_patches.inc

@@ -19,7 +19,6 @@ constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_9_0_0[] = {
     { 0x521C, "\x20\x00\x80\x52", 4 },
 };
 
-/* Patch fallback case to mov w0, #1 rather than retrieving settings flag. */
 constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_10_0_0[] = {
     { 0x5494, "\x20\x00\x80\x52", 4 },
 };
@@ -30,16 +29,21 @@ constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_11_0_0[] = {
     { 0x866C, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
 };
 
-/* Patch getter functions to return 1. */
 constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_12_0_0[] = {
     { 0x840C, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
     { 0x849C, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
 };
 
+constexpr inline const EmbeddedPatchEntry Usb30ForceEnablePatches_13_0_0[] = {
+    { 0x8424, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
+    { 0x84B4, "\x20\x00\x80\x52\xC0\x03\x5F\xD6", 8 },
+};
+
 constexpr inline const EmbeddedPatch Usb30ForceEnablePatches[] = {
     { ParseModuleId("C0D3F4E87E8B0FE9BBE9F1968A20767F3DC08E03"), util::size(Usb30ForceEnablePatches_9_0_0),  Usb30ForceEnablePatches_9_0_0 },
     { ParseModuleId("B9C700CA8335F8BAA0D2041D8D09F772890BA988"), util::size(Usb30ForceEnablePatches_10_0_0), Usb30ForceEnablePatches_10_0_0 },
     { ParseModuleId("95BAF06A69650C215A5DD50CF8BD2A603E7AD3C2"), util::size(Usb30ForceEnablePatches_11_0_0), Usb30ForceEnablePatches_11_0_0 },
     { ParseModuleId("F3F88D90EF6B3B6358EDEBAF87D56FA88D3A081C"), util::size(Usb30ForceEnablePatches_12_0_0), Usb30ForceEnablePatches_12_0_0 }, /* 12.0.0 - 12.0.3 */
     { ParseModuleId("A109046278AA99353C20EC38B57C495B74A06D91"), util::size(Usb30ForceEnablePatches_12_0_0), Usb30ForceEnablePatches_12_0_0 }, /* 12.1.0 */
-};
+    { ParseModuleId("69384BF4A543C62C4342C94E5E2CED3C5A675251"), util::size(Usb30ForceEnablePatches_13_0_0), Usb30ForceEnablePatches_13_0_0 }, /* 13.0.0 - 13.1.0 */
+};

stratosphere/sm/source/sm_user_service.hpp

@@ -20,7 +20,7 @@
 namespace ams::sm {
 
     /* Service definition. */
-    class UserService : public tipc::DeferrableBase {
+    class UserService : public tipc::DeferrableBase<sm::impl::IUserInterface, /* Maximum deferrable CMIF message size: */ 0x20 + util::AlignUp(sizeof(sm::ServiceName), sizeof(u32))> {
         private:
             os::ProcessId m_process_id;
             bool m_initialized;
@@ -41,7 +41,7 @@ namespace ams::sm {
 
             Result GetServiceHandle(tipc::OutMoveHandle out_h, ServiceName service) {
                 R_UNLESS(m_initialized, sm::ResultInvalidClient());
-                return this->RegisterRetryIfDeferred(service, [&] ALWAYS_INLINE_LAMBDA () -> Result {
+                return this->RegisterRetryIfDeferred(service, [&]() ALWAYS_INLINE_LAMBDA -> Result {
                     return impl::GetServiceHandle(out_h.GetPointer(), m_process_id, service);
                 });
             }
@@ -66,7 +66,7 @@ namespace ams::sm {
             /* Atmosphere commands. */
             Result AtmosphereInstallMitm(tipc::OutMoveHandle srv_h, tipc::OutMoveHandle qry_h, ServiceName service) {
                 R_UNLESS(m_initialized, sm::ResultInvalidClient());
-                return this->RegisterRetryIfDeferred(service, [&] ALWAYS_INLINE_LAMBDA () -> Result {
+                return this->RegisterRetryIfDeferred(service, [&]() ALWAYS_INLINE_LAMBDA -> Result {
                     return impl::InstallMitm(srv_h.GetPointer(), qry_h.GetPointer(), m_process_id, service);
                 });
             }
@@ -88,7 +88,7 @@ namespace ams::sm {
 
             Result AtmosphereWaitMitm(ServiceName service) {
                 R_UNLESS(m_initialized, sm::ResultInvalidClient());
-                return this->RegisterRetryIfDeferred(service, [&] ALWAYS_INLINE_LAMBDA () -> Result {
+                return this->RegisterRetryIfDeferred(service, [&]() ALWAYS_INLINE_LAMBDA -> Result {
                     return impl::WaitMitm(service);
                 });
             }
@@ -110,7 +110,7 @@ namespace ams::sm {
 
             Result AtmosphereWaitService(ServiceName service) {
                 R_UNLESS(m_initialized, sm::ResultInvalidClient());
-                return this->RegisterRetryIfDeferred(service, [&] ALWAYS_INLINE_LAMBDA () -> Result {
+                return this->RegisterRetryIfDeferred(service, [&]() ALWAYS_INLINE_LAMBDA -> Result {
                     return impl::WaitService(service);
                 });
             }

tests/TestSvc/source/test_main.cpp

@@ -15,8 +15,8 @@
  */
 #include <stratosphere.hpp>
 
-#define CATCH_CONFIG_RUNNER
-#include "util_catch.hpp"
+#define DOCTEST_CONFIG_IMPLEMENT
+#include "util_test_framework.hpp"
 
 namespace ams {
 
@@ -62,7 +62,13 @@ namespace ams {
         }
 
         /* Run tests. */
-        Catch::Session().run(os::GetHostArgc(), os::GetHostArgv());
+        {
+            doctest::Context ctx;
+
+            ctx.applyCommandLine(os::GetHostArgc(), os::GetHostArgv());
+
+            ctx.run();
+        }
 
         AMS_INFINITE_LOOP();
 
@@ -72,7 +78,7 @@ namespace ams {
 
 }
 
-namespace Catch {
+namespace doctest {
 
     namespace {
 
@@ -89,14 +95,13 @@ namespace Catch {
 
     }
 
-    std::ostream& cout() {
+    std::ostream& get_cout() {
         static std::ostream ret(new OutputDebugStringStream);
         return ret;
     }
-    std::ostream& clog() {
-        return cout();
-    }
-    std::ostream& cerr() {
-        return clog();
+
+    std::ostream& get_cerr() {
+        return get_cout();
     }
+
 }

tests/TestSvc/source/test_preemption_priority.cpp

@@ -37,12 +37,12 @@ namespace ams::test {
 
     }
 
-    CATCH_TEST_CASE( "The scheduler is preemptive at the preemptive priority and cooperative for all other priorities" ) {
+    DOCTEST_TEST_CASE( "The scheduler is preemptive at the preemptive priority and cooperative for all other priorities" ) {
         /* Create heap. */
         ScopedHeap heap(3 * os::MemoryPageSize);
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_None)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_None)));
         ON_SCOPE_EXIT {
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_ReadWrite)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_ReadWrite)));
         };
         const uintptr_t sp_0 = heap.GetAddress() + 1 * os::MemoryPageSize;
         const uintptr_t sp_1 = heap.GetAddress() + 3 * os::MemoryPageSize;
@@ -56,21 +56,21 @@ namespace ams::test {
                     g_spinloop = true;
 
                     /* Create threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestPreemptionPriorityThreadFunction), reinterpret_cast<uintptr_t>(thread_executed + 0), sp_0, priority, core)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestPreemptionPriorityThreadFunction), reinterpret_cast<uintptr_t>(thread_executed + 1), sp_1, priority, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestPreemptionPriorityThreadFunction), reinterpret_cast<uintptr_t>(thread_executed + 0), sp_0, priority, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestPreemptionPriorityThreadFunction), reinterpret_cast<uintptr_t>(thread_executed + 1), sp_1, priority, core)));
 
                     /* Start threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
 
                     /* Wait long enough that we can be confident the threads have been balanced. */
                     svc::SleepThread(PreemptionTimeSpan.GetNanoSeconds() * 10);
 
                     /* Check that we're in a coherent state. */
                     if (IsPreemptionPriority(core, priority)) {
-                        CATCH_REQUIRE(thread_executed[0] & thread_executed[1]);
+                        DOCTEST_CHECK((thread_executed[0] & thread_executed[1]));
                     } else {
-                        CATCH_REQUIRE(thread_executed[0] ^ thread_executed[1]);
+                        DOCTEST_CHECK((thread_executed[0] ^ thread_executed[1]));
                     }
 
                     /* Stop spinlooping. */
@@ -78,12 +78,12 @@ namespace ams::test {
 
                     /* Wait for threads to exit. */
                     s32 dummy;
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::WaitSynchronization(std::addressof(dummy), thread_handles + 0, 1, -1)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::WaitSynchronization(std::addressof(dummy), thread_handles + 1, 1, -1)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::WaitSynchronization(std::addressof(dummy), thread_handles + 0, 1, -1)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::WaitSynchronization(std::addressof(dummy), thread_handles + 1, 1, -1)));
 
                     /* Close thread handles. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
             }
         }
     }

tests/TestSvc/source/test_set_heap_size.cpp

@@ -52,81 +52,81 @@ namespace ams::test {
 
     }
 
-    CATCH_TEST_CASE("svc::SetHeapSize") {
+    DOCTEST_TEST_CASE("svc::SetHeapSize") {
         svc::MemoryInfo mem_info;
         svc::PageInfo page_info;
         uintptr_t dummy;
 
         /* Reset the heap. */
         uintptr_t addr;
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
 
         /* Ensure that we don't leak memory. */
         const size_t initial_memory = GetPhysicalMemorySizeAvailable();
-        ON_SCOPE_EXIT { CATCH_REQUIRE(initial_memory == GetPhysicalMemorySizeAvailable()); };
+        ON_SCOPE_EXIT { DOCTEST_CHECK(initial_memory == GetPhysicalMemorySizeAvailable()); };
 
-        CATCH_SECTION("Unaligned and too big sizes fail") {
+        DOCTEST_SUBCASE("Unaligned and too big sizes fail") {
             for (size_t i = 1; i < svc::HeapSizeAlignment; i = util::AlignUp(i + 1, os::MemoryPageSize)){
-                CATCH_REQUIRE(svc::ResultInvalidSize::Includes(svc::SetHeapSize(std::addressof(dummy), i)));
+                DOCTEST_CHECK(svc::ResultInvalidSize::Includes(svc::SetHeapSize(std::addressof(dummy), i)));
             }
-            CATCH_REQUIRE(svc::ResultInvalidSize::Includes(svc::SetHeapSize(std::addressof(dummy), 64_GB)));
+            DOCTEST_CHECK(svc::ResultInvalidSize::Includes(svc::SetHeapSize(std::addressof(dummy), 64_GB)));
         }
 
-        CATCH_SECTION("Larger size than address space fails") {
-            CATCH_REQUIRE(svc::ResultOutOfMemory::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(svc::AddressMemoryRegionHeap39Size + 1, svc::HeapSizeAlignment))));
+        DOCTEST_SUBCASE("Larger size than address space fails") {
+            DOCTEST_CHECK(svc::ResultOutOfMemory::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(svc::AddressMemoryRegionHeap39Size + 1, svc::HeapSizeAlignment))));
         }
 
-        CATCH_SECTION("Bounded by resource limit") {
-            CATCH_REQUIRE(svc::ResultLimitReached::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(GetPhysicalMemorySizeMax() + 1, svc::HeapSizeAlignment))));
-            CATCH_REQUIRE(svc::ResultLimitReached::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(GetPhysicalMemorySizeAvailable() + 1, svc::HeapSizeAlignment))));
+        DOCTEST_SUBCASE("Bounded by resource limit") {
+            DOCTEST_CHECK(svc::ResultLimitReached::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(GetPhysicalMemorySizeMax() + 1, svc::HeapSizeAlignment))));
+            DOCTEST_CHECK(svc::ResultLimitReached::Includes(svc::SetHeapSize(std::addressof(dummy), util::AlignUp(GetPhysicalMemorySizeAvailable() + 1, svc::HeapSizeAlignment))));
         }
 
-        CATCH_SECTION("SetHeapSize gives heap memory") {
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
+        DOCTEST_SUBCASE("SetHeapSize gives heap memory") {
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
             TestMemory(addr, svc::HeapSizeAlignment, svc::MemoryState_Normal, svc::MemoryPermission_ReadWrite, 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
         }
 
-        CATCH_SECTION("SetHeapSize cannot remove read-only heap") {
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
+        DOCTEST_SUBCASE("SetHeapSize cannot remove read-only heap") {
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), addr)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), addr)));
             TestMemory(addr, svc::HeapSizeAlignment, svc::MemoryState_Normal, svc::MemoryPermission_ReadWrite, 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(addr, svc::HeapSizeAlignment, svc::MemoryPermission_Read)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(addr, svc::HeapSizeAlignment, svc::MemoryPermission_Read)));
             TestMemory(addr, svc::HeapSizeAlignment, svc::MemoryState_Normal, svc::MemoryPermission_Read, 0);
 
-            CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetHeapSize(std::addressof(dummy), 0)));
+            DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetHeapSize(std::addressof(dummy), 0)));
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(addr, svc::HeapSizeAlignment, svc::MemoryPermission_ReadWrite)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(addr, svc::HeapSizeAlignment, svc::MemoryPermission_ReadWrite)));
             TestMemory(addr, svc::HeapSizeAlignment, svc::MemoryState_Normal, svc::MemoryPermission_ReadWrite, 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
         }
 
-        CATCH_SECTION("Heap memory does not survive unmap/re-map") {
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 2 * svc::HeapSizeAlignment)));
+        DOCTEST_SUBCASE("Heap memory does not survive unmap/re-map") {
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 2 * svc::HeapSizeAlignment)));
 
             u8 * const heap = reinterpret_cast<u8 *>(addr);
 
             std::memset(heap, 0xAA, svc::HeapSizeAlignment);
             std::memset(heap + svc::HeapSizeAlignment, 0xBB, svc::HeapSizeAlignment);
 
-            CATCH_REQUIRE(heap[svc::HeapSizeAlignment] == 0xBB);
-            CATCH_REQUIRE(std::memcmp(heap + svc::HeapSizeAlignment, heap + svc::HeapSizeAlignment + 1, svc::HeapSizeAlignment - 1) == 0);
+            DOCTEST_CHECK(heap[svc::HeapSizeAlignment] == 0xBB);
+            DOCTEST_CHECK(std::memcmp(heap + svc::HeapSizeAlignment, heap + svc::HeapSizeAlignment + 1, svc::HeapSizeAlignment - 1) == 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), svc::HeapSizeAlignment)));
 
-            CATCH_REQUIRE(heap[0] == 0xAA);
-            CATCH_REQUIRE(std::memcmp(heap, heap + 1, svc::HeapSizeAlignment - 1) == 0);
+            DOCTEST_CHECK(heap[0] == 0xAA);
+            DOCTEST_CHECK(std::memcmp(heap, heap + 1, svc::HeapSizeAlignment - 1) == 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 2 * svc::HeapSizeAlignment)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 2 * svc::HeapSizeAlignment)));
 
-            CATCH_REQUIRE(heap[svc::HeapSizeAlignment] == 0x00);
-            CATCH_REQUIRE(std::memcmp(heap + svc::HeapSizeAlignment, heap + svc::HeapSizeAlignment + 1, svc::HeapSizeAlignment - 1) == 0);
+            DOCTEST_CHECK(heap[svc::HeapSizeAlignment] == 0x00);
+            DOCTEST_CHECK(std::memcmp(heap + svc::HeapSizeAlignment, heap + svc::HeapSizeAlignment + 1, svc::HeapSizeAlignment - 1) == 0);
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetHeapSize(std::addressof(addr), 0)));
         }
     }
 

tests/TestSvc/source/test_set_memory_permission.cpp

@@ -30,22 +30,22 @@ namespace ams::test {
 
     alignas(os::MemoryPageSize) constinit u8 g_memory_permission_buffer[2 * os::MemoryPageSize];
 
-    CATCH_TEST_CASE("svc::SetMemoryPermission invalid arguments") {
+    DOCTEST_TEST_CASE("svc::SetMemoryPermission invalid arguments") {
         const uintptr_t buffer = reinterpret_cast<uintptr_t>(g_memory_permission_buffer);
 
         for (size_t i = 1; i < os::MemoryPageSize; ++i) {
-            CATCH_REQUIRE(svc::ResultInvalidAddress::Includes(svc::SetMemoryPermission(buffer + i, os::MemoryPageSize, svc::MemoryPermission_Read)));
-            CATCH_REQUIRE(svc::ResultInvalidSize::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize + i, svc::MemoryPermission_Read)));
+            DOCTEST_CHECK(svc::ResultInvalidAddress::Includes(svc::SetMemoryPermission(buffer + i, os::MemoryPageSize, svc::MemoryPermission_Read)));
+            DOCTEST_CHECK(svc::ResultInvalidSize::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize + i, svc::MemoryPermission_Read)));
         }
 
-        CATCH_REQUIRE(svc::ResultInvalidSize::Includes(svc::SetMemoryPermission(buffer, 0, svc::MemoryPermission_Read)));
+        DOCTEST_CHECK(svc::ResultInvalidSize::Includes(svc::SetMemoryPermission(buffer, 0, svc::MemoryPermission_Read)));
 
         {
             const u64 vmem_end = util::AlignDown(std::numeric_limits<u64>::max(), os::MemoryPageSize);
-            CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(vmem_end, 2 * os::MemoryPageSize, svc::MemoryPermission_Read)));
+            DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(vmem_end, 2 * os::MemoryPageSize, svc::MemoryPermission_Read)));
         }
 
-        CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(svc::AddressMap39End, os::MemoryPageSize, svc::MemoryPermission_Read)));
+        DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(svc::AddressMap39End, os::MemoryPageSize, svc::MemoryPermission_Read)));
 
         for (size_t i = 0; i < 0x100; ++i) {
             const auto perm = static_cast<svc::MemoryPermission>(i);
@@ -53,14 +53,14 @@ namespace ams::test {
                 continue;
             }
 
-            CATCH_REQUIRE(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, perm)));
+            DOCTEST_CHECK(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, perm)));
         }
-        CATCH_REQUIRE(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_ReadExecute)));
-        CATCH_REQUIRE(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_Write)));
-        CATCH_REQUIRE(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_DontCare)));
+        DOCTEST_CHECK(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_ReadExecute)));
+        DOCTEST_CHECK(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_Write)));
+        DOCTEST_CHECK(svc::ResultInvalidNewMemoryPermission::Includes(svc::SetMemoryPermission(buffer, os::MemoryPageSize, svc::MemoryPermission_DontCare)));
     }
 
-    CATCH_TEST_CASE("svc::SetMemoryPermission works on specific states") {
+    DOCTEST_TEST_CASE("svc::SetMemoryPermission works on specific states") {
         /* Check that we have CodeData. */
         const uintptr_t bss_buffer = reinterpret_cast<uintptr_t>(g_memory_permission_buffer);
         TestMemory(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryState_CodeData, svc::MemoryPermission_ReadWrite, 0);
@@ -76,15 +76,15 @@ namespace ams::test {
             /* Get current mapping. */
             svc::MemoryInfo mem_info;
             svc::PageInfo page_info;
-            CATCH_REQUIRE(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), addr)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), addr)));
 
             /* Try to set permission. */
             if (CanSetMemoryPermission(mem_info.state) && mem_info.attribute == 0) {
-                CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, svc::MemoryPermission_ReadWrite)));
+                DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, svc::MemoryPermission_ReadWrite)));
                 TestMemory(mem_info.base_address, mem_info.size, mem_info.state, svc::MemoryPermission_ReadWrite, mem_info.attribute);
-                CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, mem_info.permission)));
+                DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, mem_info.permission)));
             } else {
-                CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, svc::MemoryPermission_Read)));
+                DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(mem_info.base_address, mem_info.size, svc::MemoryPermission_Read)));
             }
 
             const uintptr_t next_address = mem_info.base_address + mem_info.size;
@@ -96,25 +96,25 @@ namespace ams::test {
         }
     }
 
-    CATCH_TEST_CASE("svc::SetMemoryPermission allows for free movement between RW-, R--, ---") {
+    DOCTEST_TEST_CASE("svc::SetMemoryPermission allows for free movement between RW-, R--, ---") {
         /* Define helper. */
         auto test_set_memory_permission = [](uintptr_t address, size_t size){
             /* Get the permission. */
             svc::MemoryInfo mem_info;
             svc::PageInfo page_info;
-            CATCH_REQUIRE(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
 
             const svc::MemoryPermission legal_states[] = { svc::MemoryPermission_None, svc::MemoryPermission_Read, svc::MemoryPermission_ReadWrite };
             for (const auto src_state : legal_states) {
                 for (const auto dst_state : legal_states) {
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(address, size, svc::MemoryPermission_None)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(address, size, src_state)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(address, size, dst_state)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(address, size, svc::MemoryPermission_None)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(address, size, svc::MemoryPermission_None)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(address, size, src_state)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(address, size, dst_state)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(address, size, svc::MemoryPermission_None)));
                 }
             }
 
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(address, size, mem_info.permission)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(address, size, mem_info.permission)));
         };
 
         /* Test that we can freely move about .bss buffers. */
@@ -130,27 +130,27 @@ namespace ams::test {
         /* TODO: AliasCodeData */
     }
 
-    CATCH_TEST_CASE("svc::SetMemoryPermission fails when the memory has non-zero attribute") {
+    DOCTEST_TEST_CASE("svc::SetMemoryPermission fails when the memory has non-zero attribute") {
         const uintptr_t bss_buffer = reinterpret_cast<uintptr_t>(g_memory_permission_buffer);
         TestMemory(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryState_CodeData, svc::MemoryPermission_ReadWrite, 0);
 
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
 
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryAttribute(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryAttribute_Uncached, svc::MemoryAttribute_Uncached)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryAttribute(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryAttribute_Uncached, svc::MemoryAttribute_Uncached)));
         TestMemory(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryState_CodeData, svc::MemoryPermission_ReadWrite, svc::MemoryAttribute_Uncached);
 
-        CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
-        CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
-        CATCH_REQUIRE(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
+        DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
+        DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
+        DOCTEST_CHECK(svc::ResultInvalidCurrentMemory::Includes(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
 
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryAttribute(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryAttribute_Uncached, 0)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryAttribute(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryAttribute_Uncached, 0)));
         TestMemory(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryState_CodeData, svc::MemoryPermission_ReadWrite, 0);
 
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_None)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_Read)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(bss_buffer, sizeof(g_memory_permission_buffer), svc::MemoryPermission_ReadWrite)));
     }
 
 }

tests/TestSvc/source/test_sleep_thread.cpp

@@ -86,26 +86,26 @@ namespace ams::test {
                     svc::Handle thread_handles[2];
 
                     /* Create threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestYieldHigherOrSamePriorityThread), 0, sp_higher, priority, core)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestYieldLowerOrSamePriorityThread), 0, sp_lower, priority, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestYieldHigherOrSamePriorityThread), 0, sp_higher, priority, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestYieldLowerOrSamePriorityThread), 0, sp_lower, priority, core)));
 
                     /* Start threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
 
                     /* Wait for higher priority thread. */
                     WaitSynchronization(thread_handles[0]);
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
 
                     /* Signal the lower priority thread to exit. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SignalEvent(g_write_handles[2])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SignalEvent(g_write_handles[2])));
 
                     /* Wait for the lower priority thread. */
                     WaitSynchronization(thread_handles[1]);
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
 
                     /* Check that the switch was correct. */
-                    CATCH_REQUIRE(g_correct_switch_threads);
+                    DOCTEST_CHECK(g_correct_switch_threads);
                 }
             }
         }
@@ -118,55 +118,55 @@ namespace ams::test {
                     svc::Handle thread_handles[2];
 
                     /* Create threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestYieldHigherOrSamePriorityThread), 0, sp_higher, priority, core)));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestYieldLowerOrSamePriorityThread), 0, sp_lower, priority + 1, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 0, reinterpret_cast<uintptr_t>(&TestYieldHigherOrSamePriorityThread), 0, sp_higher, priority, core)));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(thread_handles + 1, reinterpret_cast<uintptr_t>(&TestYieldLowerOrSamePriorityThread), 0, sp_lower, priority + 1, core)));
 
                     /* Start threads. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handles[0])));
 
                     /* Wait for higher priority thread. */
                     WaitSynchronization(thread_handles[0]);
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[0])));
 
                     /* Signal the lower priority thread to exit. */
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::SignalEvent(g_write_handles[2])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::SignalEvent(g_write_handles[2])));
 
                     /* Wait for the lower priority thread. */
                     WaitSynchronization(thread_handles[1]);
-                    CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
+                    DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handles[1])));
 
                     /* Check that the switch was correct. */
-                    CATCH_REQUIRE(g_correct_switch_threads);
+                    DOCTEST_CHECK(g_correct_switch_threads);
                 }
             }
         }
 
     }
 
-    CATCH_TEST_CASE( "svc::SleepThread: Thread sleeps for time specified" ) {
+    DOCTEST_TEST_CASE( "svc::SleepThread: Thread sleeps for time specified" ) {
         for (s64 ns = 1; ns < TimeSpan::FromSeconds(1).GetNanoSeconds(); ns *= 2) {
             const auto start = os::GetSystemTickOrdered();
             svc::SleepThread(ns);
             const auto end   = os::GetSystemTickOrdered();
 
             const s64 taken_ns = (end - start).ToTimeSpan().GetNanoSeconds();
-            CATCH_REQUIRE( taken_ns >= ns );
+            DOCTEST_CHECK( taken_ns >= ns );
         }
     }
 
-    CATCH_TEST_CASE( "svc::SleepThread: Yield is behaviorally correct" ) {
+    DOCTEST_TEST_CASE( "svc::SleepThread: Yield is behaviorally correct" ) {
         /* Create events. */
         for (size_t i = 0; i < util::size(g_write_handles); ++i) {
             g_read_handles[i]  = svc::InvalidHandle;
             g_write_handles[i] = svc::InvalidHandle;
-            CATCH_REQUIRE(R_SUCCEEDED(svc::CreateEvent(g_write_handles + i, g_read_handles + i)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::CreateEvent(g_write_handles + i, g_read_handles + i)));
         }
 
         ON_SCOPE_EXIT {
             for (size_t i = 0; i < util::size(g_write_handles); ++i) {
-                CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(g_read_handles[i])));
-                CATCH_REQUIRE(R_SUCCEEDED(svc::CloseHandle(g_write_handles[i])));
+                DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(g_read_handles[i])));
+                DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(g_write_handles[i])));
                 g_read_handles[i]  = svc::InvalidHandle;
                 g_write_handles[i] = svc::InvalidHandle;
             }
@@ -174,14 +174,14 @@ namespace ams::test {
 
         /* Create heap. */
         ScopedHeap heap(3 * os::MemoryPageSize);
-        CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_None)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_None)));
         ON_SCOPE_EXIT {
-            CATCH_REQUIRE(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_ReadWrite)));
+            DOCTEST_CHECK(R_SUCCEEDED(svc::SetMemoryPermission(heap.GetAddress() + os::MemoryPageSize, os::MemoryPageSize, svc::MemoryPermission_ReadWrite)));
         };
         const uintptr_t sp_higher = heap.GetAddress() + 1 * os::MemoryPageSize;
         const uintptr_t sp_lower  = heap.GetAddress() + 3 * os::MemoryPageSize;
 
-        CATCH_SECTION("svc::SleepThread: Yields do not switch to a thread of lower priority.") {
+        DOCTEST_SUBCASE("svc::SleepThread: Yields do not switch to a thread of lower priority.") {
             /* Test yield without migration. */
             {
                 /* Configure for yield test. */
@@ -201,7 +201,7 @@ namespace ams::test {
             }
         }
 
-        CATCH_SECTION("svc::SleepThread: ToAnyThread switches to a thread of same or lower priority.") {
+        DOCTEST_SUBCASE("svc::SleepThread: ToAnyThread switches to a thread of same or lower priority.") {
             /* Test to same priority. */
             {
                 /* Configure for yield test. */
@@ -221,7 +221,7 @@ namespace ams::test {
             }
         }
 
-        CATCH_SECTION("svc::SleepThread: Yield switches to another thread of same priority.") {
+        DOCTEST_SUBCASE("svc::SleepThread: Yield switches to another thread of same priority.") {
             /* Test yield without migration. */
             {
                 /* Configure for yield test. */
@@ -241,7 +241,7 @@ namespace ams::test {
             }
         }
 
-        CATCH_SECTION("svc::SleepThread: Yield with bogus timeout does not switch to another thread same priority") {
+        DOCTEST_SUBCASE("svc::SleepThread: Yield with bogus timeout does not switch to another thread same priority") {
             /* Configure for yield test. */
             g_should_switch_threads = false;
             g_thread_wait_ns        = INT64_C(-5);

tests/TestSvc/source/test_thread_creation.arch.arm64.s

@@ -0,0 +1,43 @@
+/*
+ * 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/>.
+ */
+
+/* ams::test::TestThreadCreateRegistersOnFunctionEntry(void *ctx) */
+.section    .text._ZN3ams4test40TestThreadCreateRegistersOnFunctionEntryEPv, "ax", %progbits
+.global     _ZN3ams4test40TestThreadCreateRegistersOnFunctionEntryEPv
+.type       _ZN3ams4test40TestThreadCreateRegistersOnFunctionEntryEPv, %function
+_ZN3ams4test40TestThreadCreateRegistersOnFunctionEntryEPv:
+    /* Save all registers to our context. */
+    stp  x0,  x1, [x0, #0x00]
+    stp  x2,  x3, [x0, #0x10]
+    stp  x4,  x5, [x0, #0x20]
+    stp  x6,  x7, [x0, #0x30]
+    stp  x8,  x9, [x0, #0x40]
+    stp x10, x11, [x0, #0x50]
+    stp x12, x13, [x0, #0x60]
+    stp x14, x15, [x0, #0x70]
+    stp x16, x17, [x0, #0x80]
+    stp x18, x19, [x0, #0x90]
+    stp x20, x21, [x0, #0xA0]
+    stp x22, x23, [x0, #0xB0]
+    stp x24, x25, [x0, #0xC0]
+    stp x26, x27, [x0, #0xD0]
+    stp x28, x29, [x0, #0xE0]
+
+    mov x1, sp
+    stp x30, x1, [x0, #0xF0]
+
+    /* Exit the thread. */
+    svc     0xa

tests/TestSvc/source/test_thread_creation.cpp

@@ -0,0 +1,65 @@
+/*
+ * 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/>.
+ */
+#include <stratosphere.hpp>
+#include "util_common.hpp"
+#include "util_scoped_heap.hpp"
+
+namespace ams::test {
+
+    void TestThreadCreateRegistersOnFunctionEntry(void *ctx);
+
+    DOCTEST_TEST_CASE( "Creating a thread results in fixed register contents." ) {
+        /* Create heap. */
+        ScopedHeap heap(os::MemoryPageSize);
+
+        /* Create register buffer. */
+        u64 thread_registers[32];
+        std::memset(thread_registers, 0xCC, sizeof(thread_registers));
+
+        /* Create thread. */
+        svc::Handle thread_handle;
+        DOCTEST_CHECK(R_SUCCEEDED(svc::CreateThread(std::addressof(thread_handle), reinterpret_cast<uintptr_t>(&TestThreadCreateRegistersOnFunctionEntry), reinterpret_cast<uintptr_t>(thread_registers), heap.GetAddress() + os::MemoryPageSize, HighestTestPriority, NumCores - 1)));
+
+        /* Start thread. */
+        DOCTEST_CHECK(R_SUCCEEDED(svc::StartThread(thread_handle)));
+
+        /* Wait for thread to exit. */
+        s32 dummy;
+        DOCTEST_CHECK(R_SUCCEEDED(svc::WaitSynchronization(std::addressof(dummy), std::addressof(thread_handle), 1, -1)));
+
+        /* Close thread handle. */
+        DOCTEST_CHECK(R_SUCCEEDED(svc::CloseHandle(thread_handle)));
+
+        /* Check thread initial registers. */
+        for (size_t i = 0; i < util::size(thread_registers); ++i) {
+            if (i == 0) {
+                /* X0 is argument. */
+                DOCTEST_CHECK(thread_registers[i] == reinterpret_cast<uintptr_t>(thread_registers));
+            } else if (i == 18) {
+                /* X18 is an odd cfi value. */
+                DOCTEST_CHECK(thread_registers[i] != 0);
+                DOCTEST_CHECK((thread_registers[i] & 0x1) != 0);
+            } else if (i == 31) {
+                /* SP is user-provided sp. */
+                DOCTEST_CHECK(thread_registers[i] == (heap.GetAddress() + os::MemoryPageSize));
+            } else {
+                /* All other registers are zero. */
+                DOCTEST_CHECK(thread_registers[i] == 0);
+            }
+        }
+    }
+
+}

tests/TestSvc/source/test_thread_pinning.cpp

@@ -0,0 +1,28 @@
+/*
+ * 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/>.
+ */
+#include <stratosphere.hpp>
+#include "util_common.hpp"
+#include "util_scoped_heap.hpp"
+
+namespace ams::test {
+
+    DOCTEST_TEST_CASE( "Setting a thread's disable count will cause it to become pinned." ) {
+        DoWithThreadPinning([]() {
+            __asm__ __volatile__("" ::: "memory");
+        });
+    }
+
+}

tests/TestSvc/source/util_check_memory.hpp

@@ -14,33 +14,33 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #pragma once
-#include "util_catch.hpp"
+#include "util_test_framework.hpp"
 
 namespace ams::test {
 
     inline void TestMemory(uintptr_t address, svc::MemoryState state, svc::MemoryPermission perm, u32 attr) {
         svc::MemoryInfo mem_info;
         svc::PageInfo page_info;
-        CATCH_REQUIRE(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
 
-        CATCH_REQUIRE(mem_info.base_address <= address);
-        CATCH_REQUIRE(address < (mem_info.base_address + mem_info.size));
-        CATCH_REQUIRE(mem_info.state == state);
-        CATCH_REQUIRE(mem_info.permission == perm);
-        CATCH_REQUIRE(mem_info.attribute == attr);
+        DOCTEST_CHECK(mem_info.base_address <= address);
+        DOCTEST_CHECK(address < (mem_info.base_address + mem_info.size));
+        DOCTEST_CHECK(mem_info.state == state);
+        DOCTEST_CHECK(mem_info.permission == perm);
+        DOCTEST_CHECK(mem_info.attribute == attr);
     }
 
     inline void TestMemory(uintptr_t address, size_t size, svc::MemoryState state, svc::MemoryPermission perm, u32 attr) {
         svc::MemoryInfo mem_info;
         svc::PageInfo page_info;
-        CATCH_REQUIRE(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
+        DOCTEST_CHECK(R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), address)));
 
-        CATCH_REQUIRE(mem_info.base_address <= address);
-        CATCH_REQUIRE(mem_info.base_address < (address + size));
-        CATCH_REQUIRE((address + size) <= (mem_info.base_address + mem_info.size));
-        CATCH_REQUIRE(mem_info.state == state);
-        CATCH_REQUIRE(mem_info.permission == perm);
-        CATCH_REQUIRE(mem_info.attribute == attr);
+        DOCTEST_CHECK(mem_info.base_address <= address);
+        DOCTEST_CHECK(mem_info.base_address < (address + size));
+        DOCTEST_CHECK((address + size) <= (mem_info.base_address + mem_info.size));
+        DOCTEST_CHECK(mem_info.state == state);
+        DOCTEST_CHECK(mem_info.permission == perm);
+        DOCTEST_CHECK(mem_info.attribute == attr);
     }
 
 }

tests/TestSvc/source/util_common.hpp

@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #pragma once
-#include "util_catch.hpp"
+#include "util_test_framework.hpp"
 
 namespace ams::test {
 
@@ -32,4 +32,70 @@ namespace ams::test {
         return priority == ((core == (NumCores - 1)) ? DpcManagerPreemptionThreadPriority : DpcManagerNormalThreadPriority);
     }
 
+    template<typename F>
+    void DoWithThreadPinning(F f) {
+        /* Get the thread local region. */
+        auto * const tlr = svc::GetThreadLocalRegion();
+
+        /* Require that we're not currently pinned. */
+        DOCTEST_CHECK((tlr->disable_count == 0));
+        DOCTEST_CHECK((!tlr->interrupt_flag));
+
+        /* Request to pin ourselves. */
+        tlr->disable_count = 1;
+
+        /* Wait long enough that we can be confident preemption will occur, and therefore our interrupt flag will be set. */
+        {
+            constexpr auto MinimumTicksToGuaranteeInterruptFlag = ::ams::svc::Tick(PreemptionTimeSpan) + ::ams::svc::Tick(PreemptionTimeSpan) + 2;
+
+            auto GetSystemTickForPinnedThread = []() ALWAYS_INLINE_LAMBDA -> ::ams::svc::Tick {
+                s64 v;
+                __asm__ __volatile__ ("mrs %x[v], cntpct_el0" : [v]"=r"(v) :: "memory");
+                return ::ams::svc::Tick(v);
+            };
+
+            const auto start_tick = GetSystemTickForPinnedThread();
+            while (true) {
+                if (tlr->interrupt_flag) {
+                    break;
+                }
+
+                if (const auto cur_tick = GetSystemTickForPinnedThread(); (cur_tick - start_tick) > MinimumTicksToGuaranteeInterruptFlag) {
+                    break;
+                }
+            }
+        }
+
+        /* We're pinned. Execute the user callback. */
+        bool callback_succeeded = true;
+        {
+            if constexpr (requires { { f() } -> std::convertible_to<bool>; }) {
+                callback_succeeded = f();
+            } else {
+                f();
+            }
+        }
+
+        /* Clear our disable count. */
+        tlr->disable_count = 0;
+
+        /* Get our interrupt flag. */
+        const auto interrupt_flag_while_pinned = tlr->interrupt_flag;
+
+        /* Unpin ourselves. */
+        if (interrupt_flag_while_pinned) {
+            svc::SynchronizePreemptionState();
+        }
+
+        /* Get our interrupt flag. */
+        const auto interrupt_flag_after_unpin = tlr->interrupt_flag;
+
+        /* We have access to all SVCs again. Check that our pinning happened as expected. */
+        DOCTEST_CHECK(interrupt_flag_while_pinned);
+        DOCTEST_CHECK(!interrupt_flag_after_unpin);
+
+        /* Check that our callback succeeded. */
+        DOCTEST_CHECK(callback_succeeded);
+    }
+
 }

tests/TestSvc/source/util_scoped_heap.hpp

@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #pragma once
-#include "util_catch.hpp"
+#include "util_test_framework.hpp"
 
 namespace ams::test {
 
@@ -31,14 +31,14 @@ namespace ams::test {
 
             ~ScopedHeap() {
                 const auto result = svc::SetHeapSize(std::addressof(m_address), 0);
-                CATCH_REQUIRE(R_SUCCEEDED(result));
+                DOCTEST_CHECK(R_SUCCEEDED(result));
             }
 
             void SetHeapSize(size_t size) {
                 m_size = util::AlignUp(size, svc::HeapSizeAlignment);
 
                 const auto result = svc::SetHeapSize(std::addressof(m_address), m_size);
-                CATCH_REQUIRE(R_SUCCEEDED(result));
+                DOCTEST_CHECK(R_SUCCEEDED(result));
             }
 
             uintptr_t GetAddress() const { return m_address; }

tests/TestSvc/source/util_test_framework.hpp

@@ -17,7 +17,8 @@
 #include <stratosphere.hpp>
 
 #define CATCH_CONFIG_NOSTDOUT
-#define CATCH_CONFIG_PREFIX_ALL
-#define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#define CATCH_CONFIG_NO_POSIX_SIGNALS
-#include "catch.hpp"
+#define DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+#define DOCTEST_CONFIG_NO_EXCEPTIONS
+#define DOCTEST_CONFIG_NO_POSIX_SIGNALS
+#include "doctest.h"