kern: add svc stubs, turn on svc table build

libraries/libmesosphere/include/mesosphere/svc/kern_svc_prototypes.hpp

@@ -21,9 +21,9 @@
 namespace ams::kern::svc {
 
     #define AMS_KERN_SVC_DECLARE_PROTOTYPE_64(ID, RETURN_TYPE, NAME, ...) \
-        RETURN_TYPE NAME##64(__VA_ARGS__);
+        NOINLINE RETURN_TYPE NAME##64(__VA_ARGS__);
     #define AMS_KERN_SVC_DECLARE_PROTOTYPE_64_FROM_32(ID, RETURN_TYPE, NAME, ...) \
-        RETURN_TYPE NAME##64From32(__VA_ARGS__);
+        NOINLINE RETURN_TYPE NAME##64From32(__VA_ARGS__);
 
     AMS_SVC_FOREACH_KERN_DEFINITION(AMS_KERN_SVC_DECLARE_PROTOTYPE_64,         lp64)
     AMS_SVC_FOREACH_KERN_DEFINITION(AMS_KERN_SVC_DECLARE_PROTOTYPE_64_FROM_32, ilp32)

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

@@ -13,7 +13,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+#ifdef MESOSPHERE_USE_STUBBED_SVC_TABLES
 #include <mesosphere/kern_debug_log.hpp>
+#endif
+
 #include <mesosphere/svc/kern_svc_tables.hpp>
 #include <vapours/svc/svc_codegen.hpp>
 
@@ -21,8 +24,7 @@ namespace ams::kern::svc {
 
     namespace {
 
-        /* TODO: Enable compilation of this file when the kernel supports supervisor calls. */
+        #ifndef MESOSPHERE_USE_STUBBED_SVC_TABLES
-        #if 0
             #define DECLARE_SVC_STRUCT(ID, RETURN_TYPE, NAME, ...)                                                                        \
                 class NAME {                                                                                                              \
                     private:                                                                                                              \
@@ -35,8 +37,8 @@ namespace ams::kern::svc {
             #define DECLARE_SVC_STRUCT(ID, RETURN_TYPE, NAME, ...)                                                                        \
                 class NAME {                                                                                                              \
                     public:                                                                                                               \
-                        static NOINLINE void Call64()       { MESOSPHERE_LOG("Stubbed Svc"#NAME"64 was called\n"); }                      \
+                        static NOINLINE void Call64()       { MESOSPHERE_PANIC("Stubbed Svc"#NAME"64 was called"); }                      \
-                        static NOINLINE void Call64From32() { MESOSPHERE_LOG("Stubbed Svc"#NAME"64From32 was called\n"); }                \
+                        static NOINLINE void Call64From32() { MESOSPHERE_PANIC("Stubbed Svc"#NAME"64From32 was called"); }                \
                 };
         #endif
 

libraries/libmesosphere/source/svc/kern_svc_activity.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SetThreadActivity64(ams::svc::Handle thread_handle, ams::svc::ThreadActivity thread_activity) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadActivity64 was called.");
+    }
+
+    Result SetProcessActivity64(ams::svc::Handle process_handle, ams::svc::ProcessActivity process_activity) {
+        MESOSPHERE_PANIC("Stubbed SvcSetProcessActivity64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SetThreadActivity64From32(ams::svc::Handle thread_handle, ams::svc::ThreadActivity thread_activity) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadActivity64From32 was called.");
+    }
+
+    Result SetProcessActivity64From32(ams::svc::Handle process_handle, ams::svc::ProcessActivity process_activity) {
+        MESOSPHERE_PANIC("Stubbed SvcSetProcessActivity64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_address_arbiter.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result WaitForAddress64(ams::svc::Address address, ams::svc::ArbitrationType arb_type, int32_t value, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitForAddress64 was called.");
+    }
+
+    Result SignalToAddress64(ams::svc::Address address, ams::svc::SignalType signal_type, int32_t value, int32_t count) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalToAddress64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result WaitForAddress64From32(ams::svc::Address address, ams::svc::ArbitrationType arb_type, int32_t value, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitForAddress64From32 was called.");
+    }
+
+    Result SignalToAddress64From32(ams::svc::Address address, ams::svc::SignalType signal_type, int32_t value, int32_t count) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalToAddress64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_address_translation.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result QueryPhysicalAddress64(ams::svc::lp64::PhysicalMemoryInfo *out_info, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryPhysicalAddress64 was called.");
+    }
+
+    Result QueryIoMapping64(ams::svc::Address *out_address, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryIoMapping64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result QueryPhysicalAddress64From32(ams::svc::ilp32::PhysicalMemoryInfo *out_info, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryPhysicalAddress64From32 was called.");
+    }
+
+    Result QueryIoMapping64From32(ams::svc::Address *out_address, ams::svc::PhysicalAddress physical_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryIoMapping64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_cache.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void FlushEntireDataCache64() {
+        MESOSPHERE_PANIC("Stubbed SvcFlushEntireDataCache64 was called.");
+    }
+
+    Result FlushDataCache64(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcFlushDataCache64 was called.");
+    }
+
+    Result InvalidateProcessDataCache64(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcInvalidateProcessDataCache64 was called.");
+    }
+
+    Result StoreProcessDataCache64(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcStoreProcessDataCache64 was called.");
+    }
+
+    Result FlushProcessDataCache64(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcFlushProcessDataCache64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void FlushEntireDataCache64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcFlushEntireDataCache64From32 was called.");
+    }
+
+    Result FlushDataCache64From32(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcFlushDataCache64From32 was called.");
+    }
+
+    Result InvalidateProcessDataCache64From32(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcInvalidateProcessDataCache64From32 was called.");
+    }
+
+    Result StoreProcessDataCache64From32(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcStoreProcessDataCache64From32 was called.");
+    }
+
+    Result FlushProcessDataCache64From32(ams::svc::Handle process_handle, uint64_t address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcFlushProcessDataCache64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_code_memory.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CreateCodeMemory64(ams::svc::Handle *out_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateCodeMemory64 was called.");
+    }
+
+    Result ControlCodeMemory64(ams::svc::Handle code_memory_handle, ams::svc::CodeMemoryOperation operation, uint64_t address, uint64_t size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcControlCodeMemory64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CreateCodeMemory64From32(ams::svc::Handle *out_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateCodeMemory64From32 was called.");
+    }
+
+    Result ControlCodeMemory64From32(ams::svc::Handle code_memory_handle, ams::svc::CodeMemoryOperation operation, uint64_t address, uint64_t size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcControlCodeMemory64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_condition_variable.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result WaitProcessWideKeyAtomic64(ams::svc::Address address, ams::svc::Address cv_key, uint32_t tag, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitProcessWideKeyAtomic64 was called.");
+    }
+
+    void SignalProcessWideKey64(ams::svc::Address cv_key, int32_t count) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalProcessWideKey64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result WaitProcessWideKeyAtomic64From32(ams::svc::Address address, ams::svc::Address cv_key, uint32_t tag, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitProcessWideKeyAtomic64From32 was called.");
+    }
+
+    void SignalProcessWideKey64From32(ams::svc::Address cv_key, int32_t count) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalProcessWideKey64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_debug.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result DebugActiveProcess64(ams::svc::Handle *out_handle, uint64_t process_id) {
+        MESOSPHERE_PANIC("Stubbed SvcDebugActiveProcess64 was called.");
+    }
+
+    Result BreakDebugProcess64(ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcBreakDebugProcess64 was called.");
+    }
+
+    Result TerminateDebugProcess64(ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcTerminateDebugProcess64 was called.");
+    }
+
+    Result GetDebugEvent64(KUserPointer<ams::svc::lp64::DebugEventInfo *> out_info, ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugEvent64 was called.");
+    }
+
+    Result ContinueDebugEvent64(ams::svc::Handle debug_handle, uint32_t flags, KUserPointer<const uint64_t *> thread_ids, int32_t num_thread_ids) {
+        MESOSPHERE_PANIC("Stubbed SvcContinueDebugEvent64 was called.");
+    }
+
+    Result GetDebugThreadContext64(KUserPointer<ams::svc::ThreadContext *> out_context, ams::svc::Handle debug_handle, uint64_t thread_id, uint32_t context_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugThreadContext64 was called.");
+    }
+
+    Result SetDebugThreadContext64(ams::svc::Handle debug_handle, uint64_t thread_id, KUserPointer<const ams::svc::ThreadContext *> context, uint32_t context_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcSetDebugThreadContext64 was called.");
+    }
+
+    Result QueryDebugProcessMemory64(KUserPointer<ams::svc::lp64::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Handle process_handle, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryDebugProcessMemory64 was called.");
+    }
+
+    Result ReadDebugProcessMemory64(ams::svc::Address buffer, ams::svc::Handle debug_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcReadDebugProcessMemory64 was called.");
+    }
+
+    Result WriteDebugProcessMemory64(ams::svc::Handle debug_handle, ams::svc::Address buffer, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcWriteDebugProcessMemory64 was called.");
+    }
+
+    Result SetHardwareBreakPoint64(ams::svc::HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value) {
+        MESOSPHERE_PANIC("Stubbed SvcSetHardwareBreakPoint64 was called.");
+    }
+
+    Result GetDebugThreadParam64(uint64_t *out_64, uint32_t *out_32, ams::svc::Handle debug_handle, uint64_t thread_id, ams::svc::DebugThreadParam param) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugThreadParam64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result DebugActiveProcess64From32(ams::svc::Handle *out_handle, uint64_t process_id) {
+        MESOSPHERE_PANIC("Stubbed SvcDebugActiveProcess64From32 was called.");
+    }
+
+    Result BreakDebugProcess64From32(ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcBreakDebugProcess64From32 was called.");
+    }
+
+    Result TerminateDebugProcess64From32(ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcTerminateDebugProcess64From32 was called.");
+    }
+
+    Result GetDebugEvent64From32(KUserPointer<ams::svc::ilp32::DebugEventInfo *> out_info, ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugEvent64From32 was called.");
+    }
+
+    Result ContinueDebugEvent64From32(ams::svc::Handle debug_handle, uint32_t flags, KUserPointer<const uint64_t *> thread_ids, int32_t num_thread_ids) {
+        MESOSPHERE_PANIC("Stubbed SvcContinueDebugEvent64From32 was called.");
+    }
+
+    Result GetDebugThreadContext64From32(KUserPointer<ams::svc::ThreadContext *> out_context, ams::svc::Handle debug_handle, uint64_t thread_id, uint32_t context_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugThreadContext64From32 was called.");
+    }
+
+    Result SetDebugThreadContext64From32(ams::svc::Handle debug_handle, uint64_t thread_id, KUserPointer<const ams::svc::ThreadContext *> context, uint32_t context_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcSetDebugThreadContext64From32 was called.");
+    }
+
+    Result QueryDebugProcessMemory64From32(KUserPointer<ams::svc::ilp32::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Handle process_handle, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryDebugProcessMemory64From32 was called.");
+    }
+
+    Result ReadDebugProcessMemory64From32(ams::svc::Address buffer, ams::svc::Handle debug_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcReadDebugProcessMemory64From32 was called.");
+    }
+
+    Result WriteDebugProcessMemory64From32(ams::svc::Handle debug_handle, ams::svc::Address buffer, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcWriteDebugProcessMemory64From32 was called.");
+    }
+
+    Result SetHardwareBreakPoint64From32(ams::svc::HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value) {
+        MESOSPHERE_PANIC("Stubbed SvcSetHardwareBreakPoint64From32 was called.");
+    }
+
+    Result GetDebugThreadParam64From32(uint64_t *out_64, uint32_t *out_32, ams::svc::Handle debug_handle, uint64_t thread_id, ams::svc::DebugThreadParam param) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugThreadParam64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_debug_string.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result OutputDebugString64(KUserPointer<const char *> debug_str, ams::svc::Size len) {
+        MESOSPHERE_PANIC("Stubbed SvcOutputDebugString64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result OutputDebugString64From32(KUserPointer<const char *> debug_str, ams::svc::Size len) {
+        MESOSPHERE_PANIC("Stubbed SvcOutputDebugString64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_device_address_space.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CreateDeviceAddressSpace64(ams::svc::Handle *out_handle, uint64_t das_address, uint64_t das_size) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateDeviceAddressSpace64 was called.");
+    }
+
+    Result AttachDeviceAddressSpace64(ams::svc::DeviceName device_name, ams::svc::Handle das_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcAttachDeviceAddressSpace64 was called.");
+    }
+
+    Result DetachDeviceAddressSpace64(ams::svc::DeviceName device_name, ams::svc::Handle das_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcDetachDeviceAddressSpace64 was called.");
+    }
+
+    Result MapDeviceAddressSpaceByForce64(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpaceByForce64 was called.");
+    }
+
+    Result MapDeviceAddressSpaceAligned64(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpaceAligned64 was called.");
+    }
+
+    Result MapDeviceAddressSpace64(ams::svc::Size *out_mapped_size, ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpace64 was called.");
+    }
+
+    Result UnmapDeviceAddressSpace64(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapDeviceAddressSpace64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CreateDeviceAddressSpace64From32(ams::svc::Handle *out_handle, uint64_t das_address, uint64_t das_size) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateDeviceAddressSpace64From32 was called.");
+    }
+
+    Result AttachDeviceAddressSpace64From32(ams::svc::DeviceName device_name, ams::svc::Handle das_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcAttachDeviceAddressSpace64From32 was called.");
+    }
+
+    Result DetachDeviceAddressSpace64From32(ams::svc::DeviceName device_name, ams::svc::Handle das_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcDetachDeviceAddressSpace64From32 was called.");
+    }
+
+    Result MapDeviceAddressSpaceByForce64From32(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpaceByForce64From32 was called.");
+    }
+
+    Result MapDeviceAddressSpaceAligned64From32(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpaceAligned64From32 was called.");
+    }
+
+    Result MapDeviceAddressSpace64From32(ams::svc::Size *out_mapped_size, ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address, ams::svc::MemoryPermission device_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapDeviceAddressSpace64From32 was called.");
+    }
+
+    Result UnmapDeviceAddressSpace64From32(ams::svc::Handle das_handle, ams::svc::Handle process_handle, uint64_t process_address, ams::svc::Size size, uint64_t device_address) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapDeviceAddressSpace64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_event.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SignalEvent64(ams::svc::Handle event_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalEvent64 was called.");
+    }
+
+    Result ClearEvent64(ams::svc::Handle event_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcClearEvent64 was called.");
+    }
+
+    Result CreateEvent64(ams::svc::Handle *out_write_handle, ams::svc::Handle *out_read_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateEvent64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SignalEvent64From32(ams::svc::Handle event_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSignalEvent64From32 was called.");
+    }
+
+    Result ClearEvent64From32(ams::svc::Handle event_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcClearEvent64From32 was called.");
+    }
+
+    Result CreateEvent64From32(ams::svc::Handle *out_write_handle, ams::svc::Handle *out_read_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateEvent64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_exception.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void Break64(ams::svc::BreakReason break_reason, ams::svc::Address arg, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcBreak64 was called.");
+    }
+
+    void ReturnFromException64(ams::Result result) {
+        MESOSPHERE_PANIC("Stubbed SvcReturnFromException64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void Break64From32(ams::svc::BreakReason break_reason, ams::svc::Address arg, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcBreak64From32 was called.");
+    }
+
+    void ReturnFromException64From32(ams::Result result) {
+        MESOSPHERE_PANIC("Stubbed SvcReturnFromException64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_info.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result GetInfo64(uint64_t *out, ams::svc::InfoType info_type, ams::svc::Handle handle, uint64_t info_subtype) {
+        MESOSPHERE_PANIC("Stubbed SvcGetInfo64 was called.");
+    }
+
+    Result GetSystemInfo64(uint64_t *out, ams::svc::SystemInfoType info_type, ams::svc::Handle handle, uint64_t info_subtype) {
+        MESOSPHERE_PANIC("Stubbed SvcGetSystemInfo64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result GetInfo64From32(uint64_t *out, ams::svc::InfoType info_type, ams::svc::Handle handle, uint64_t info_subtype) {
+        MESOSPHERE_PANIC("Stubbed SvcGetInfo64From32 was called.");
+    }
+
+    Result GetSystemInfo64From32(uint64_t *out, ams::svc::SystemInfoType info_type, ams::svc::Handle handle, uint64_t info_subtype) {
+        MESOSPHERE_PANIC("Stubbed SvcGetSystemInfo64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_interrupt_event.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CreateInterruptEvent64(ams::svc::Handle *out_read_handle, int32_t interrupt_id, ams::svc::InterruptType interrupt_type) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateInterruptEvent64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CreateInterruptEvent64From32(ams::svc::Handle *out_read_handle, int32_t interrupt_id, ams::svc::InterruptType interrupt_type) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateInterruptEvent64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_ipc.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SendSyncRequest64(ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequest64 was called.");
+    }
+
+    Result SendSyncRequestWithUserBuffer64(ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequestWithUserBuffer64 was called.");
+    }
+
+    Result SendAsyncRequestWithUserBuffer64(ams::svc::Handle *out_event_handle, ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendAsyncRequestWithUserBuffer64 was called.");
+    }
+
+    Result ReplyAndReceive64(int32_t *out_index, KUserPointer<const ams::svc::Handle *> handles, int32_t num_handles, ams::svc::Handle reply_target, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceive64 was called.");
+    }
+
+    Result ReplyAndReceiveWithUserBuffer64(int32_t *out_index, ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, KUserPointer<const ams::svc::Handle *> handles, int32_t num_handles, ams::svc::Handle reply_target, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceiveWithUserBuffer64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SendSyncRequest64From32(ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequest64From32 was called.");
+    }
+
+    Result SendSyncRequestWithUserBuffer64From32(ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequestWithUserBuffer64From32 was called.");
+    }
+
+    Result SendAsyncRequestWithUserBuffer64From32(ams::svc::Handle *out_event_handle, ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendAsyncRequestWithUserBuffer64From32 was called.");
+    }
+
+    Result ReplyAndReceive64From32(int32_t *out_index, KUserPointer<const ams::svc::Handle *> handles, int32_t num_handles, ams::svc::Handle reply_target, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceive64From32 was called.");
+    }
+
+    Result ReplyAndReceiveWithUserBuffer64From32(int32_t *out_index, ams::svc::Address message_buffer, ams::svc::Size message_buffer_size, KUserPointer<const ams::svc::Handle *> handles, int32_t num_handles, ams::svc::Handle reply_target, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceiveWithUserBuffer64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_kernel_debug.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void KernelDebug64(ams::svc::KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2) {
+        MESOSPHERE_PANIC("Stubbed SvcKernelDebug64 was called.");
+    }
+
+    void ChangeKernelTraceState64(ams::svc::KernelTraceState kern_trace_state) {
+        MESOSPHERE_PANIC("Stubbed SvcChangeKernelTraceState64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void KernelDebug64From32(ams::svc::KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2) {
+        MESOSPHERE_PANIC("Stubbed SvcKernelDebug64From32 was called.");
+    }
+
+    void ChangeKernelTraceState64From32(ams::svc::KernelTraceState kern_trace_state) {
+        MESOSPHERE_PANIC("Stubbed SvcChangeKernelTraceState64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_light_ipc.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SendSyncRequestLight64(ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequestLight64 was called.");
+    }
+
+    Result ReplyAndReceiveLight64(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceiveLight64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SendSyncRequestLight64From32(ams::svc::Handle session_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcSendSyncRequestLight64From32 was called.");
+    }
+
+    Result ReplyAndReceiveLight64From32(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcReplyAndReceiveLight64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_lock.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result ArbitrateLock64(ams::svc::Handle thread_handle, ams::svc::Address address, uint32_t tag) {
+        MESOSPHERE_PANIC("Stubbed SvcArbitrateLock64 was called.");
+    }
+
+    Result ArbitrateUnlock64(ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcArbitrateUnlock64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result ArbitrateLock64From32(ams::svc::Handle thread_handle, ams::svc::Address address, uint32_t tag) {
+        MESOSPHERE_PANIC("Stubbed SvcArbitrateLock64From32 was called.");
+    }
+
+    Result ArbitrateUnlock64From32(ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcArbitrateUnlock64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_memory.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SetMemoryPermission64(ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcSetMemoryPermission64 was called.");
+    }
+
+    Result SetMemoryAttribute64(ams::svc::Address address, ams::svc::Size size, uint32_t mask, uint32_t attr) {
+        MESOSPHERE_PANIC("Stubbed SvcSetMemoryAttribute64 was called.");
+    }
+
+    Result MapMemory64(ams::svc::Address dst_address, ams::svc::Address src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapMemory64 was called.");
+    }
+
+    Result UnmapMemory64(ams::svc::Address dst_address, ams::svc::Address src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapMemory64 was called.");
+    }
+
+    Result QueryMemory64(KUserPointer<ams::svc::lp64::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryMemory64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SetMemoryPermission64From32(ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcSetMemoryPermission64From32 was called.");
+    }
+
+    Result SetMemoryAttribute64From32(ams::svc::Address address, ams::svc::Size size, uint32_t mask, uint32_t attr) {
+        MESOSPHERE_PANIC("Stubbed SvcSetMemoryAttribute64From32 was called.");
+    }
+
+    Result MapMemory64From32(ams::svc::Address dst_address, ams::svc::Address src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapMemory64From32 was called.");
+    }
+
+    Result UnmapMemory64From32(ams::svc::Address dst_address, ams::svc::Address src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapMemory64From32 was called.");
+    }
+
+    Result QueryMemory64From32(KUserPointer<ams::svc::ilp32::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Address address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryMemory64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_physical_memory.cpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SetHeapSize64(ams::svc::Address *out_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcSetHeapSize64 was called.");
+    }
+
+    Result MapPhysicalMemory64(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapPhysicalMemory64 was called.");
+    }
+
+    Result UnmapPhysicalMemory64(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapPhysicalMemory64 was called.");
+    }
+
+    Result MapPhysicalMemoryUnsafe64(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapPhysicalMemoryUnsafe64 was called.");
+    }
+
+    Result UnmapPhysicalMemoryUnsafe64(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapPhysicalMemoryUnsafe64 was called.");
+    }
+
+    Result SetUnsafeLimit64(ams::svc::Size limit) {
+        MESOSPHERE_PANIC("Stubbed SvcSetUnsafeLimit64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SetHeapSize64From32(ams::svc::Address *out_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcSetHeapSize64From32 was called.");
+    }
+
+    Result MapPhysicalMemory64From32(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapPhysicalMemory64From32 was called.");
+    }
+
+    Result UnmapPhysicalMemory64From32(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapPhysicalMemory64From32 was called.");
+    }
+
+    Result MapPhysicalMemoryUnsafe64From32(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapPhysicalMemoryUnsafe64From32 was called.");
+    }
+
+    Result UnmapPhysicalMemoryUnsafe64From32(ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapPhysicalMemoryUnsafe64From32 was called.");
+    }
+
+    Result SetUnsafeLimit64From32(ams::svc::Size limit) {
+        MESOSPHERE_PANIC("Stubbed SvcSetUnsafeLimit64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_port.cpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result ConnectToNamedPort64(ams::svc::Handle *out_handle, KUserPointer<const char *> name) {
+        MESOSPHERE_PANIC("Stubbed SvcConnectToNamedPort64 was called.");
+    }
+
+    Result CreatePort64(ams::svc::Handle *out_server_handle, ams::svc::Handle *out_client_handle, int32_t max_sessions, bool is_light, ams::svc::Address name) {
+        MESOSPHERE_PANIC("Stubbed SvcCreatePort64 was called.");
+    }
+
+    Result ManageNamedPort64(ams::svc::Handle *out_server_handle, KUserPointer<const char *> name, int32_t max_sessions) {
+        MESOSPHERE_PANIC("Stubbed SvcManageNamedPort64 was called.");
+    }
+
+    Result ConnectToPort64(ams::svc::Handle *out_handle, ams::svc::Handle port) {
+        MESOSPHERE_PANIC("Stubbed SvcConnectToPort64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result ConnectToNamedPort64From32(ams::svc::Handle *out_handle, KUserPointer<const char *> name) {
+        MESOSPHERE_PANIC("Stubbed SvcConnectToNamedPort64From32 was called.");
+    }
+
+    Result CreatePort64From32(ams::svc::Handle *out_server_handle, ams::svc::Handle *out_client_handle, int32_t max_sessions, bool is_light, ams::svc::Address name) {
+        MESOSPHERE_PANIC("Stubbed SvcCreatePort64From32 was called.");
+    }
+
+    Result ManageNamedPort64From32(ams::svc::Handle *out_server_handle, KUserPointer<const char *> name, int32_t max_sessions) {
+        MESOSPHERE_PANIC("Stubbed SvcManageNamedPort64From32 was called.");
+    }
+
+    Result ConnectToPort64From32(ams::svc::Handle *out_handle, ams::svc::Handle port) {
+        MESOSPHERE_PANIC("Stubbed SvcConnectToPort64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_power_management.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void SleepSystem64() {
+        MESOSPHERE_PANIC("Stubbed SvcSleepSystem64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void SleepSystem64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcSleepSystem64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_process.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void ExitProcess64() {
+        MESOSPHERE_PANIC("Stubbed SvcExitProcess64 was called.");
+    }
+
+    Result GetProcessId64(uint64_t *out_process_id, ams::svc::Handle process_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessId64 was called.");
+    }
+
+    Result GetProcessList64(int32_t *out_num_processes, KUserPointer<uint64_t *> out_process_ids, int32_t max_out_count) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessList64 was called.");
+    }
+
+    Result CreateProcess64(ams::svc::Handle *out_handle, KUserPointer<const ams::svc::lp64::CreateProcessParameter *> parameters, KUserPointer<const uint32_t *> caps, int32_t num_caps) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateProcess64 was called.");
+    }
+
+    Result StartProcess64(ams::svc::Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size) {
+        MESOSPHERE_PANIC("Stubbed SvcStartProcess64 was called.");
+    }
+
+    Result TerminateProcess64(ams::svc::Handle process_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcTerminateProcess64 was called.");
+    }
+
+    Result GetProcessInfo64(int64_t *out_info, ams::svc::Handle process_handle, ams::svc::ProcessInfoType info_type) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessInfo64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void ExitProcess64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcExitProcess64From32 was called.");
+    }
+
+    Result GetProcessId64From32(uint64_t *out_process_id, ams::svc::Handle process_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessId64From32 was called.");
+    }
+
+    Result GetProcessList64From32(int32_t *out_num_processes, KUserPointer<uint64_t *> out_process_ids, int32_t max_out_count) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessList64From32 was called.");
+    }
+
+    Result CreateProcess64From32(ams::svc::Handle *out_handle, KUserPointer<const ams::svc::ilp32::CreateProcessParameter *> parameters, KUserPointer<const uint32_t *> caps, int32_t num_caps) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateProcess64From32 was called.");
+    }
+
+    Result StartProcess64From32(ams::svc::Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size) {
+        MESOSPHERE_PANIC("Stubbed SvcStartProcess64From32 was called.");
+    }
+
+    Result TerminateProcess64From32(ams::svc::Handle process_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcTerminateProcess64From32 was called.");
+    }
+
+    Result GetProcessInfo64From32(int64_t *out_info, ams::svc::Handle process_handle, ams::svc::ProcessInfoType info_type) {
+        MESOSPHERE_PANIC("Stubbed SvcGetProcessInfo64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_process_memory.cpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result SetProcessMemoryPermission64(ams::svc::Handle process_handle, uint64_t address, uint64_t size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcSetProcessMemoryPermission64 was called.");
+    }
+
+    Result MapProcessMemory64(ams::svc::Address dst_address, ams::svc::Handle process_handle, uint64_t src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapProcessMemory64 was called.");
+    }
+
+    Result UnmapProcessMemory64(ams::svc::Address dst_address, ams::svc::Handle process_handle, uint64_t src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapProcessMemory64 was called.");
+    }
+
+    Result QueryProcessMemory64(KUserPointer<ams::svc::lp64::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Handle process_handle, uint64_t address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryProcessMemory64 was called.");
+    }
+
+    Result MapProcessCodeMemory64(ams::svc::Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapProcessCodeMemory64 was called.");
+    }
+
+    Result UnmapProcessCodeMemory64(ams::svc::Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapProcessCodeMemory64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result SetProcessMemoryPermission64From32(ams::svc::Handle process_handle, uint64_t address, uint64_t size, ams::svc::MemoryPermission perm) {
+        MESOSPHERE_PANIC("Stubbed SvcSetProcessMemoryPermission64From32 was called.");
+    }
+
+    Result MapProcessMemory64From32(ams::svc::Address dst_address, ams::svc::Handle process_handle, uint64_t src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapProcessMemory64From32 was called.");
+    }
+
+    Result UnmapProcessMemory64From32(ams::svc::Address dst_address, ams::svc::Handle process_handle, uint64_t src_address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapProcessMemory64From32 was called.");
+    }
+
+    Result QueryProcessMemory64From32(KUserPointer<ams::svc::ilp32::MemoryInfo *> out_memory_info, ams::svc::PageInfo *out_page_info, ams::svc::Handle process_handle, uint64_t address) {
+        MESOSPHERE_PANIC("Stubbed SvcQueryProcessMemory64From32 was called.");
+    }
+
+    Result MapProcessCodeMemory64From32(ams::svc::Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcMapProcessCodeMemory64From32 was called.");
+    }
+
+    Result UnmapProcessCodeMemory64From32(ams::svc::Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapProcessCodeMemory64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_processor.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    int32_t GetCurrentProcessorNumber64() {
+        MESOSPHERE_PANIC("Stubbed SvcGetCurrentProcessorNumber64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    int32_t GetCurrentProcessorNumber64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcGetCurrentProcessorNumber64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_register.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result ReadWriteRegister64(uint32_t *out_value, ams::svc::PhysicalAddress address, uint32_t mask, uint32_t value) {
+        MESOSPHERE_PANIC("Stubbed SvcReadWriteRegister64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result ReadWriteRegister64From32(uint32_t *out_value, ams::svc::PhysicalAddress address, uint32_t mask, uint32_t value) {
+        MESOSPHERE_PANIC("Stubbed SvcReadWriteRegister64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_resource_limit.cpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result GetResourceLimitLimitValue64(int64_t *out_limit_value, ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which) {
+        MESOSPHERE_PANIC("Stubbed SvcGetResourceLimitLimitValue64 was called.");
+    }
+
+    Result GetResourceLimitCurrentValue64(int64_t *out_current_value, ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which) {
+        MESOSPHERE_PANIC("Stubbed SvcGetResourceLimitCurrentValue64 was called.");
+    }
+
+    Result CreateResourceLimit64(ams::svc::Handle *out_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateResourceLimit64 was called.");
+    }
+
+    Result SetResourceLimitLimitValue64(ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which, int64_t limit_value) {
+        MESOSPHERE_PANIC("Stubbed SvcSetResourceLimitLimitValue64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result GetResourceLimitLimitValue64From32(int64_t *out_limit_value, ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which) {
+        MESOSPHERE_PANIC("Stubbed SvcGetResourceLimitLimitValue64From32 was called.");
+    }
+
+    Result GetResourceLimitCurrentValue64From32(int64_t *out_current_value, ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which) {
+        MESOSPHERE_PANIC("Stubbed SvcGetResourceLimitCurrentValue64From32 was called.");
+    }
+
+    Result CreateResourceLimit64From32(ams::svc::Handle *out_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateResourceLimit64From32 was called.");
+    }
+
+    Result SetResourceLimitLimitValue64From32(ams::svc::Handle resource_limit_handle, ams::svc::LimitableResource which, int64_t limit_value) {
+        MESOSPHERE_PANIC("Stubbed SvcSetResourceLimitLimitValue64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_secure_monitor_call.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    void CallSecureMonitor64(ams::svc::lp64::SecureMonitorArguments *args) {
+        MESOSPHERE_PANIC("Stubbed SvcCallSecureMonitor64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    void CallSecureMonitor64From32(ams::svc::ilp32::SecureMonitorArguments *args) {
+        MESOSPHERE_PANIC("Stubbed SvcCallSecureMonitor64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_session.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CreateSession64(ams::svc::Handle *out_server_session_handle, ams::svc::Handle *out_client_session_handle, bool is_light, ams::svc::Address name) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateSession64 was called.");
+    }
+
+    Result AcceptSession64(ams::svc::Handle *out_handle, ams::svc::Handle port) {
+        MESOSPHERE_PANIC("Stubbed SvcAcceptSession64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CreateSession64From32(ams::svc::Handle *out_server_session_handle, ams::svc::Handle *out_client_session_handle, bool is_light, ams::svc::Address name) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateSession64From32 was called.");
+    }
+
+    Result AcceptSession64From32(ams::svc::Handle *out_handle, ams::svc::Handle port) {
+        MESOSPHERE_PANIC("Stubbed SvcAcceptSession64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_shared_memory.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result MapSharedMemory64(ams::svc::Handle shmem_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission map_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapSharedMemory64 was called.");
+    }
+
+    Result UnmapSharedMemory64(ams::svc::Handle shmem_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapSharedMemory64 was called.");
+    }
+
+    Result CreateSharedMemory64(ams::svc::Handle *out_handle, ams::svc::Size size, ams::svc::MemoryPermission owner_perm, ams::svc::MemoryPermission remote_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateSharedMemory64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result MapSharedMemory64From32(ams::svc::Handle shmem_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission map_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapSharedMemory64From32 was called.");
+    }
+
+    Result UnmapSharedMemory64From32(ams::svc::Handle shmem_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapSharedMemory64From32 was called.");
+    }
+
+    Result CreateSharedMemory64From32(ams::svc::Handle *out_handle, ams::svc::Size size, ams::svc::MemoryPermission owner_perm, ams::svc::MemoryPermission remote_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateSharedMemory64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_synchronization.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CloseHandle64(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCloseHandle64 was called.");
+    }
+
+    Result ResetSignal64(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcResetSignal64 was called.");
+    }
+
+    Result WaitSynchronization64(int32_t *out_index, KUserPointer<const ams::svc::Handle *> handles, int32_t numHandles, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitSynchronization64 was called.");
+    }
+
+    Result CancelSynchronization64(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCancelSynchronization64 was called.");
+    }
+
+    void SynchronizePreemptionState64() {
+        MESOSPHERE_PANIC("Stubbed SvcSynchronizePreemptionState64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CloseHandle64From32(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCloseHandle64From32 was called.");
+    }
+
+    Result ResetSignal64From32(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcResetSignal64From32 was called.");
+    }
+
+    Result WaitSynchronization64From32(int32_t *out_index, KUserPointer<const ams::svc::Handle *> handles, int32_t numHandles, int64_t timeout_ns) {
+        MESOSPHERE_PANIC("Stubbed SvcWaitSynchronization64From32 was called.");
+    }
+
+    Result CancelSynchronization64From32(ams::svc::Handle handle) {
+        MESOSPHERE_PANIC("Stubbed SvcCancelSynchronization64From32 was called.");
+    }
+
+    void SynchronizePreemptionState64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcSynchronizePreemptionState64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_thread.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result CreateThread64(ams::svc::Handle *out_handle, ams::svc::ThreadFunc func, ams::svc::Address arg, ams::svc::Address stack_bottom, int32_t priority, int32_t core_id) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateThread64 was called.");
+    }
+
+    Result StartThread64(ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcStartThread64 was called.");
+    }
+
+    void ExitThread64() {
+        MESOSPHERE_PANIC("Stubbed SvcExitThread64 was called.");
+    }
+
+    void SleepThread64(int64_t ns) {
+        MESOSPHERE_PANIC("Stubbed SvcSleepThread64 was called.");
+    }
+
+    Result GetThreadPriority64(int32_t *out_priority, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadPriority64 was called.");
+    }
+
+    Result SetThreadPriority64(ams::svc::Handle thread_handle, int32_t priority) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadPriority64 was called.");
+    }
+
+    Result GetThreadCoreMask64(int32_t *out_core_id, uint64_t *out_affinity_mask, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadCoreMask64 was called.");
+    }
+
+    Result SetThreadCoreMask64(ams::svc::Handle thread_handle, int32_t core_id, uint64_t affinity_mask) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadCoreMask64 was called.");
+    }
+
+    Result GetThreadId64(uint64_t *out_thread_id, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadId64 was called.");
+    }
+
+    Result GetDebugFutureThreadInfo64(ams::svc::lp64::LastThreadContext *out_context, uint64_t *thread_id, ams::svc::Handle debug_handle, int64_t ns) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugFutureThreadInfo64 was called.");
+    }
+
+    Result GetLastThreadInfo64(ams::svc::lp64::LastThreadContext *out_context, ams::svc::Address *out_tls_address, uint32_t *out_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcGetLastThreadInfo64 was called.");
+    }
+
+    Result GetThreadContext364(KUserPointer<ams::svc::ThreadContext *> out_context, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadContext364 was called.");
+    }
+
+    Result GetThreadList64(int32_t *out_num_threads, KUserPointer<uint64_t *> out_thread_ids, int32_t max_out_count, ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadList64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result CreateThread64From32(ams::svc::Handle *out_handle, ams::svc::ThreadFunc func, ams::svc::Address arg, ams::svc::Address stack_bottom, int32_t priority, int32_t core_id) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateThread64From32 was called.");
+    }
+
+    Result StartThread64From32(ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcStartThread64From32 was called.");
+    }
+
+    void ExitThread64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcExitThread64From32 was called.");
+    }
+
+    void SleepThread64From32(int64_t ns) {
+        MESOSPHERE_PANIC("Stubbed SvcSleepThread64From32 was called.");
+    }
+
+    Result GetThreadPriority64From32(int32_t *out_priority, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadPriority64From32 was called.");
+    }
+
+    Result SetThreadPriority64From32(ams::svc::Handle thread_handle, int32_t priority) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadPriority64From32 was called.");
+    }
+
+    Result GetThreadCoreMask64From32(int32_t *out_core_id, uint64_t *out_affinity_mask, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadCoreMask64From32 was called.");
+    }
+
+    Result SetThreadCoreMask64From32(ams::svc::Handle thread_handle, int32_t core_id, uint64_t affinity_mask) {
+        MESOSPHERE_PANIC("Stubbed SvcSetThreadCoreMask64From32 was called.");
+    }
+
+    Result GetThreadId64From32(uint64_t *out_thread_id, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadId64From32 was called.");
+    }
+
+    Result GetDebugFutureThreadInfo64From32(ams::svc::ilp32::LastThreadContext *out_context, uint64_t *thread_id, ams::svc::Handle debug_handle, int64_t ns) {
+        MESOSPHERE_PANIC("Stubbed SvcGetDebugFutureThreadInfo64From32 was called.");
+    }
+
+    Result GetLastThreadInfo64From32(ams::svc::ilp32::LastThreadContext *out_context, ams::svc::Address *out_tls_address, uint32_t *out_flags) {
+        MESOSPHERE_PANIC("Stubbed SvcGetLastThreadInfo64From32 was called.");
+    }
+
+    Result GetThreadContext364From32(KUserPointer<ams::svc::ThreadContext *> out_context, ams::svc::Handle thread_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadContext364From32 was called.");
+    }
+
+    Result GetThreadList64From32(int32_t *out_num_threads, KUserPointer<uint64_t *> out_thread_ids, int32_t max_out_count, ams::svc::Handle debug_handle) {
+        MESOSPHERE_PANIC("Stubbed SvcGetThreadList64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_tick.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    int64_t GetSystemTick64() {
+        MESOSPHERE_PANIC("Stubbed SvcGetSystemTick64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    int64_t GetSystemTick64From32() {
+        MESOSPHERE_PANIC("Stubbed SvcGetSystemTick64From32 was called.");
+    }
+
+}

libraries/libmesosphere/source/svc/kern_svc_transfer_memory.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018-2020 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 <mesosphere.hpp>
+
+namespace ams::kern::svc {
+
+    /* =============================    Common    ============================= */
+
+    namespace {
+
+
+
+    }
+
+    /* =============================    64 ABI    ============================= */
+
+    Result MapTransferMemory64From32(ams::svc::Handle trmem_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission owner_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapTransferMemory64From32 was called.");
+    }
+
+    Result UnmapTransferMemory64From32(ams::svc::Handle trmem_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapTransferMemory64From32 was called.");
+    }
+
+    Result CreateTransferMemory64(ams::svc::Handle *out_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission map_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateTransferMemory64 was called.");
+    }
+
+    /* ============================= 64From32 ABI ============================= */
+
+    Result MapTransferMemory64(ams::svc::Handle trmem_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission owner_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcMapTransferMemory64 was called.");
+    }
+
+    Result UnmapTransferMemory64(ams::svc::Handle trmem_handle, ams::svc::Address address, ams::svc::Size size) {
+        MESOSPHERE_PANIC("Stubbed SvcUnmapTransferMemory64 was called.");
+    }
+
+    Result CreateTransferMemory64From32(ams::svc::Handle *out_handle, ams::svc::Address address, ams::svc::Size size, ams::svc::MemoryPermission map_perm) {
+        MESOSPHERE_PANIC("Stubbed SvcCreateTransferMemory64From32 was called.");
+    }
+
+}