Integrate new result macros. (Atmosphere-NX#1780)

* result: try out some experimental shenanigans

* result: sketch out some more shenanigans

* result: see what it looks like to convert kernel to use result conds instead of guards

* make rest of kernel use experimental new macro-ing

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table.hpp

@@ -191,20 +191,20 @@ namespace ams::kern::arch::arm64 {
             Result Map(KProcessAddress virt_addr, KPhysicalAddress phys_addr, size_t num_pages, PageTableEntry entry_template, bool disable_head_merge, size_t page_size, PageLinkedList *page_list, bool reuse_ll) {
                 switch (page_size) {
                     case L1BlockSize:
-                        return this->MapL1Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll);
+                        R_RETURN(this->MapL1Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll));
                     case L2ContiguousBlockSize:
                         entry_template.SetContiguous(true);
                         [[fallthrough]];
 #ifdef ATMOSPHERE_BOARD_NINTENDO_NX
                     case L2TegraSmmuBlockSize:
 #endif
                     case L2BlockSize:
-                        return this->MapL2Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll);
+                        R_RETURN(this->MapL2Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll));
                     case L3ContiguousBlockSize:
                         entry_template.SetContiguous(true);
                         [[fallthrough]];
                     case L3BlockSize:
-                        return this->MapL3Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll);
+                        R_RETURN(this->MapL3Blocks(virt_addr, phys_addr, num_pages, entry_template, disable_head_merge, page_list, reuse_ll));
                     MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
                 }
             }

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_supervisor_page_table.hpp

@@ -42,19 +42,19 @@ namespace ams::kern::arch::arm64 {
             }
 
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
-                return m_page_table.MapPages(out_addr, num_pages, alignment, phys_addr, region_start, region_num_pages, state, perm);
+                R_RETURN(m_page_table.MapPages(out_addr, num_pages, alignment, phys_addr, region_start, region_num_pages, state, perm));
             }
 
             Result UnmapPages(KProcessAddress address, size_t num_pages, KMemoryState state) {
-                return m_page_table.UnmapPages(address, num_pages, state);
+                R_RETURN(m_page_table.UnmapPages(address, num_pages, state));
             }
 
             Result MapPageGroup(KProcessAddress *out_addr, const KPageGroup &pg, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
-                return m_page_table.MapPageGroup(out_addr, pg, region_start, region_num_pages, state, perm);
+                R_RETURN(m_page_table.MapPageGroup(out_addr, pg, region_start, region_num_pages, state, perm));
             }
 
             Result UnmapPageGroup(KProcessAddress address, const KPageGroup &pg, KMemoryState state) {
-                return m_page_table.UnmapPageGroup(address, pg, state);
+                R_RETURN(m_page_table.UnmapPageGroup(address, pg, state));
             }
 
             bool GetPhysicalAddress(KPhysicalAddress *out, KProcessAddress address) const {

libraries/libmesosphere/include/mesosphere/board/generic/kern_k_device_page_table.hpp

@@ -29,29 +29,29 @@ namespace ams::kern::board::generic {
 
             Result ALWAYS_INLINE Initialize(u64 space_address, u64 space_size) {
                 MESOSPHERE_UNUSED(space_address, space_size);
-                return ams::kern::svc::ResultNotImplemented();
+                R_THROW(ams::kern::svc::ResultNotImplemented());
             }
 
             void ALWAYS_INLINE Finalize() { /* ... */ }
 
             Result ALWAYS_INLINE Attach(ams::svc::DeviceName device_name, u64 space_address, u64 space_size) {
                 MESOSPHERE_UNUSED(device_name, space_address, space_size);
-                return ams::kern::svc::ResultNotImplemented();
+                R_THROW(ams::kern::svc::ResultNotImplemented());
             }
 
             Result ALWAYS_INLINE Detach(ams::svc::DeviceName device_name) {
                 MESOSPHERE_UNUSED(device_name);
-                return ams::kern::svc::ResultNotImplemented();
+                R_THROW(ams::kern::svc::ResultNotImplemented());
             }
 
             Result ALWAYS_INLINE Map(KProcessPageTable *page_table, KProcessAddress process_address, size_t size, KDeviceVirtualAddress device_address, ams::svc::MemoryPermission device_perm, bool is_aligned) {
                 MESOSPHERE_UNUSED(page_table, process_address, size, device_address, device_perm, is_aligned);
-                return ams::kern::svc::ResultNotImplemented();
+                R_THROW(ams::kern::svc::ResultNotImplemented());
             }
 
             Result ALWAYS_INLINE Unmap(KProcessPageTable *page_table, KProcessAddress process_address, size_t size, KDeviceVirtualAddress device_address) {
                 MESOSPHERE_UNUSED(page_table, process_address, size, device_address);
-                return ams::kern::svc::ResultNotImplemented();
+                R_THROW(ams::kern::svc::ResultNotImplemented());
             }
 
             void ALWAYS_INLINE Unmap(KDeviceVirtualAddress device_address, size_t size) {

libraries/libmesosphere/include/mesosphere/kern_k_address_arbiter.hpp

@@ -30,23 +30,23 @@ namespace ams::kern {
             Result SignalToAddress(uintptr_t addr, ams::svc::SignalType type, s32 value, s32 count) {
                 switch (type) {
                     case ams::svc::SignalType_Signal:
-                        return this->Signal(addr, count);
+                        R_RETURN(this->Signal(addr, count));
                     case ams::svc::SignalType_SignalAndIncrementIfEqual:
-                        return this->SignalAndIncrementIfEqual(addr, value, count);
+                        R_RETURN(this->SignalAndIncrementIfEqual(addr, value, count));
                     case ams::svc::SignalType_SignalAndModifyByWaitingCountIfEqual:
-                        return this->SignalAndModifyByWaitingCountIfEqual(addr, value, count);
+                        R_RETURN(this->SignalAndModifyByWaitingCountIfEqual(addr, value, count));
                     MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
                 }
             }
 
             Result WaitForAddress(uintptr_t addr, ams::svc::ArbitrationType type, s32 value, s64 timeout) {
                 switch (type) {
                     case ams::svc::ArbitrationType_WaitIfLessThan:
-                        return this->WaitIfLessThan(addr, value, false, timeout);
+                        R_RETURN(this->WaitIfLessThan(addr, value, false, timeout));
                     case ams::svc::ArbitrationType_DecrementAndWaitIfLessThan:
-                        return this->WaitIfLessThan(addr, value, true, timeout);
+                        R_RETURN(this->WaitIfLessThan(addr, value, true, timeout));
                     case ams::svc::ArbitrationType_WaitIfEqual:
-                        return this->WaitIfEqual(addr, value, timeout);
+                        R_RETURN(this->WaitIfEqual(addr, value, timeout));
                     MESOSPHERE_UNREACHABLE_DEFAULT_CASE();
                 }
             }

libraries/libmesosphere/include/mesosphere/kern_k_device_address_space.hpp

@@ -42,11 +42,11 @@ namespace ams::kern {
             Result Detach(ams::svc::DeviceName device_name);
 
             Result MapByForce(KProcessPageTable *page_table, KProcessAddress process_address, size_t size, u64 device_address, ams::svc::MemoryPermission device_perm) {
-                return this->Map(page_table, process_address, size, device_address, device_perm, false);
+                R_RETURN(this->Map(page_table, process_address, size, device_address, device_perm, false));
             }
 
             Result MapAligned(KProcessPageTable *page_table, KProcessAddress process_address, size_t size, u64 device_address, ams::svc::MemoryPermission device_perm) {
-                return this->Map(page_table, process_address, size, device_address, device_perm, true);
+                R_RETURN(this->Map(page_table, process_address, size, device_address, device_perm, true));
             }
 
             Result Unmap(KProcessPageTable *page_table, KProcessAddress process_address, size_t size, u64 device_address);

libraries/libmesosphere/include/mesosphere/kern_k_dynamic_page_manager.hpp

@@ -72,7 +72,7 @@ namespace ams::kern {
                     m_page_bitmap.SetBit(i);
                 }
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             constexpr KVirtualAddress GetAddress() const { return m_address; }

libraries/libmesosphere/include/mesosphere/kern_k_handle_table.hpp

@@ -93,7 +93,7 @@ namespace ams::kern {
                     m_free_head_index                = i;
                 }
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             constexpr ALWAYS_INLINE size_t GetTableSize() const { return m_table_size; }

libraries/libmesosphere/include/mesosphere/kern_k_interrupt_event.hpp

@@ -46,7 +46,7 @@ namespace ams::kern {
                 /* Try to perform a reset, succeeding unconditionally. */
                 this->Reset();
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             bool IsInitialized() const { return m_is_initialized; }

libraries/libmesosphere/include/mesosphere/kern_k_light_session.hpp

@@ -62,7 +62,7 @@ namespace ams::kern {
             bool IsServerClosed() const { return m_state != State::Normal; }
             bool IsClientClosed() const { return m_state != State::Normal; }
 
-            Result OnRequest(KThread *request_thread) { return m_server.OnRequest(request_thread); }
+            Result OnRequest(KThread *request_thread) { R_RETURN(m_server.OnRequest(request_thread)); }
 
             KLightClientSession &GetClientSession() { return m_client; }
             KLightServerSession &GetServerSession() { return m_server; }

libraries/libmesosphere/include/mesosphere/kern_k_memory_block_manager.hpp

@@ -41,7 +41,7 @@ namespace ams::kern {
                     R_UNLESS(m_blocks[m_index + i] != nullptr, svc::ResultOutOfResource());
                 }
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
         public:
             KMemoryBlockManagerUpdateAllocator(Result *out_result, KMemoryBlockSlabManager *sm, size_t num_blocks = MaxBlocks) : m_blocks(), m_index(MaxBlocks), m_slab_manager(sm) {

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -284,16 +284,16 @@ namespace ams::kern {
 
             Result CheckMemoryStateContiguous(size_t *out_blocks_needed, KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr) const;
             Result CheckMemoryStateContiguous(KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr) const {
-                return this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr);
+                R_RETURN(this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr));
             }
 
             Result CheckMemoryState(const KMemoryInfo &info, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr) const;
             Result CheckMemoryState(KMemoryState *out_state, KMemoryPermission *out_perm, KMemoryAttribute *out_attr, size_t *out_blocks_needed, KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr, u32 ignore_attr = DefaultMemoryIgnoreAttr) const;
             Result CheckMemoryState(size_t *out_blocks_needed, KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr, u32 ignore_attr = DefaultMemoryIgnoreAttr) const {
-                return this->CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr);
+                R_RETURN(this->CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr));
             }
             Result CheckMemoryState(KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr, u32 ignore_attr = DefaultMemoryIgnoreAttr) const {
-                return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr);
+                R_RETURN(this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr));
             }
 
             Result LockMemoryAndOpen(KPageGroup *out_pg, KPhysicalAddress *out_paddr, KProcessAddress addr, size_t size, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr, KMemoryPermission new_perm, u32 lock_attr);
@@ -351,8 +351,8 @@ namespace ams::kern {
             Result SetMaxHeapSize(size_t size);
             Result QueryInfo(KMemoryInfo *out_info, ams::svc::PageInfo *out_page_info, KProcessAddress addr) const;
             Result QueryPhysicalAddress(ams::svc::PhysicalMemoryInfo *out, KProcessAddress address) const;
-            Result QueryStaticMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const { return this->QueryMappingImpl(out, address, size, KMemoryState_Static); }
-            Result QueryIoMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const { return this->QueryMappingImpl(out, address, size, KMemoryState_Io); }
+            Result QueryStaticMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const { R_RETURN(this->QueryMappingImpl(out, address, size, KMemoryState_Static)); }
+            Result QueryIoMapping(KProcessAddress *out, KPhysicalAddress address, size_t size) const { R_RETURN(this->QueryMappingImpl(out, address, size, KMemoryState_Io)); }
             Result MapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
             Result UnmapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
             Result MapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
@@ -364,15 +364,15 @@ namespace ams::kern {
             Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm);
 
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
-                return this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start, region_num_pages, state, perm);
+                R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start, region_num_pages, state, perm));
             }
 
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
-                return this->MapPages(out_addr, num_pages, alignment, phys_addr, true, this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize, state, perm);
+                R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize, state, perm));
             }
 
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, KMemoryState state, KMemoryPermission perm) {
-                return this->MapPages(out_addr, num_pages, PageSize, Null<KPhysicalAddress>, false, this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize, state, perm);
+                R_RETURN(this->MapPages(out_addr, num_pages, PageSize, Null<KPhysicalAddress>, false, this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize, state, perm));
             }
 
             Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state, KMemoryPermission perm);

libraries/libmesosphere/include/mesosphere/kern_k_process.hpp

@@ -356,15 +356,15 @@ namespace ams::kern {
             }
 
             Result WaitConditionVariable(KProcessAddress address, uintptr_t cv_key, u32 tag, s64 ns) {
-                return m_cond_var.Wait(address, cv_key, tag, ns);
+                R_RETURN(m_cond_var.Wait(address, cv_key, tag, ns));
             }
 
             Result SignalAddressArbiter(uintptr_t address, ams::svc::SignalType signal_type, s32 value, s32 count) {
-                return m_address_arbiter.SignalToAddress(address, signal_type, value, count);
+                R_RETURN(m_address_arbiter.SignalToAddress(address, signal_type, value, count));
             }
 
             Result WaitAddressArbiter(uintptr_t address, ams::svc::ArbitrationType arb_type, s32 value, s64 timeout) {
-                return m_address_arbiter.WaitForAddress(address, arb_type, value, timeout);
+                R_RETURN(m_address_arbiter.WaitForAddress(address, arb_type, value, timeout));
             }
 
             Result GetThreadList(s32 *out_num_threads, ams::kern::svc::KUserPointer<u64 *> out_thread_ids, s32 max_out_count);
@@ -415,7 +415,7 @@ namespace ams::kern {
 
                 /* We succeeded, so note that we did. */
                 m_is_handle_table_initialized = true;
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             ALWAYS_INLINE void FinalizeHandleTable() {

libraries/libmesosphere/include/mesosphere/kern_k_readable_event.hpp

@@ -44,7 +44,7 @@ namespace ams::kern {
                 /* Try to perform a reset, succeeding unconditionally. */
                 this->Reset();
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             virtual bool IsSignaled() const override;

libraries/libmesosphere/include/mesosphere/kern_k_session.hpp

@@ -75,7 +75,7 @@ namespace ams::kern {
             bool IsServerClosed() const { return this->GetState() != State::Normal; }
             bool IsClientClosed() const { return this->GetState() != State::Normal; }
 
-            Result OnRequest(KSessionRequest *request) { return m_server.OnRequest(request); }
+            Result OnRequest(KSessionRequest *request) { R_RETURN(m_server.OnRequest(request)); }
 
             KClientSession &GetClientSession() { return m_client; }
             KServerSession &GetServerSession() { return m_server; }

libraries/libmesosphere/include/mesosphere/kern_k_session_request.hpp

@@ -190,15 +190,15 @@ namespace ams::kern {
             constexpr ALWAYS_INLINE size_t GetExchangeCount() const { return m_mappings.GetExchangeCount(); }
 
             ALWAYS_INLINE Result PushSend(KProcessAddress client, KProcessAddress server, size_t size, KMemoryState state) {
-                return m_mappings.PushSend(client, server, size, state);
+                R_RETURN(m_mappings.PushSend(client, server, size, state));
             }
 
             ALWAYS_INLINE Result PushReceive(KProcessAddress client, KProcessAddress server, size_t size, KMemoryState state) {
-                return m_mappings.PushReceive(client, server, size, state);
+                R_RETURN(m_mappings.PushReceive(client, server, size, state));
             }
 
             ALWAYS_INLINE Result PushExchange(KProcessAddress client, KProcessAddress server, size_t size, KMemoryState state) {
-                return m_mappings.PushExchange(client, server, size, state);
+                R_RETURN(m_mappings.PushExchange(client, server, size, state));
             }
 
             constexpr ALWAYS_INLINE KProcessAddress GetSendClientAddress(size_t i) const { return m_mappings.GetSendClientAddress(i); }