strat: fix nx_debug build target

This change was made for #2255, but the issue creator never confirmed if it resolved the issue.

This *does* better reflect what Nintendo's pm does, though, so I'm going to commit it regardless.

libraries/libstratosphere/source/fs/fs_romfs_filesystem.cpp

@@ -500,7 +500,7 @@ namespace ams::fs {
 
         R_UNLESS((mode & fs::OpenMode_All) == fs::OpenMode_Read, fs::ResultInvalidOpenMode());
 
-        RomFileTable::FileInfo file_info;
+        RomFileTable::FileInfo file_info{};
         R_TRY(this->GetFileInfo(std::addressof(file_info), path.GetString()));
 
         auto file = std::make_unique<RomFsFile>(this, m_entry_size + file_info.offset.Get(), m_entry_size + file_info.offset.Get() + file_info.size.Get());

libraries/libstratosphere/source/htc/server/rpc/htc_rpc_client.cpp

@@ -288,7 +288,7 @@ namespace ams::htc::server::rpc {
             /* Get a task. */
             Task *task;
             u32 task_id{};
-            PacketCategory category;
+            PacketCategory category{};
             do {
                 /* Dequeue a task. */
                 R_TRY(m_task_queue.Take(std::addressof(task_id), std::addressof(category)));

libraries/libstratosphere/source/htcs/impl/htcs_manager.cpp

@@ -39,7 +39,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Socket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation) {
         /* Invoke our implementation. */
-        s32 err, desc;
+        s32 err = -1, desc = -1;
         const Result result = m_impl->CreateSocket(std::addressof(err), std::addressof(desc), enable_disconnection_emulation);
 
         /* Set output. */
@@ -71,7 +71,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Connect(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Connect(std::addressof(err), desc, address);
 
         /* Set output. */
@@ -90,7 +90,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Bind(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Bind(std::addressof(err), desc, address);
 
         /* Set output. */
@@ -109,7 +109,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Listen(s32 *out_err, s32 *out_res, s32 backlog_count, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Listen(std::addressof(err), desc, backlog_count);
 
         /* Set output. */
@@ -128,8 +128,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Recv(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 flags, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 recv_size;
+        s64 recv_size = -1;
         const Result result = m_impl->Receive(std::addressof(err), std::addressof(recv_size), buffer, size, desc, flags);
 
         /* Set output. */
@@ -148,8 +148,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 flags, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 send_size;
+        s64 send_size = -1;
         const Result result = m_impl->Send(std::addressof(err), std::addressof(send_size), buffer, size, desc, flags);
 
         /* Set output. */
@@ -168,7 +168,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Shutdown(s32 *out_err, s32 *out_res, s32 how, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->Shutdown(std::addressof(err), desc, how);
 
         /* Set output. */
@@ -191,7 +191,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::Fcntl(s32 *out_err, s32 *out_res, s32 command, s32 value, s32 desc) {
         /* Invoke our implementation. */
-        s32 err, res;
+        s32 err = -1, res = -1;
         const Result result = m_impl->Fcntl(std::addressof(err), std::addressof(res), desc, command, value);
 
         /* Set output. */
@@ -210,7 +210,7 @@ namespace ams::htcs::impl {
 
     void HtcsManager::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
         const Result result = m_impl->AcceptResults(std::addressof(err), out_desc, out_address, task_id, desc);
 
         /* Set output. */
@@ -233,8 +233,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 size;
+        s64 size = -1;
         const Result result = m_impl->RecvResults(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
 
         /* Set output. */
@@ -265,8 +265,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 size;
+        s64 size = -1;
         const Result result = m_impl->SendResults(std::addressof(err), std::addressof(size), task_id, desc);
 
         /* Set output. */
@@ -293,7 +293,7 @@ namespace ams::htcs::impl {
 
     Result HtcsManager::ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s64 size;
+        s64 size = -1;
         R_TRY_CATCH(m_impl->ContinueSend(std::addressof(size), buffer, buffer_size, task_id, desc)) {
             R_CONVERT(htclow::ResultInvalidChannelState, tma::ResultUnknown())
             R_CONVERT(htc::ResultTaskCancelled,          tma::ResultUnknown())
@@ -306,8 +306,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 size;
+        s64 size = -1;
         const Result result = m_impl->EndSend(std::addressof(err), std::addressof(size), task_id, desc);
 
         /* Set output. */
@@ -334,8 +334,8 @@ namespace ams::htcs::impl {
 
     void HtcsManager::EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        s64 size;
+        s64 size = -1;
         const Result result = m_impl->EndRecv(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
 
         /* Set output. */
@@ -367,8 +367,8 @@ namespace ams::htcs::impl {
 
     Result HtcsManager::EndSelect(s32 *out_err, s32 *out_count, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
         /* Invoke our implementation. */
-        s32 err;
+        s32 err = -1;
-        bool empty;
+        bool empty = false;
         const Result result = m_impl->EndSelect(std::addressof(err), std::addressof(empty), read_handles, write_handles, exception_handles, task_id);
 
         /* Set output. */

stratosphere/ams_mitm/source/dns_mitm/dnsmitm_host_redirection.cpp

@@ -107,9 +107,9 @@ namespace ams::mitm::socket::resolver {
                 HostName,
             };
 
-            ams::socket::InAddrT current_address;
+            ams::socket::InAddrT current_address{};
             char current_hostname[0x200];
-            u32 work;
+            u32 work{};
 
             State state = State::BeginLine;
             for (const char *cur = file_data; *cur != '\x00'; ++cur) {

stratosphere/pm/source/impl/pm_spec.cpp

@@ -243,29 +243,35 @@ namespace ams::pm::impl {
             const u64 boost_size = normal_boost + mitm_boost;
 
             /* Don't allow all application memory to be taken away. */
-            R_UNLESS(boost_size <= g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
+            R_UNLESS(boost_size < g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application], pm::ResultInvalidSize());
 
             const u64 new_app_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_Application] - boost_size;
             {
                 std::scoped_lock lk(g_resource_limit_lock);
 
+                const auto cur_boost_size = GetCurrentSystemMemoryBoostSize();
+
                 if (hos::GetVersion() >= hos::Version_5_0_0) {
                     /* Starting in 5.0.0, PM does not allow for only one of the sets to fail. */
-                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                    if (boost_size < cur_boost_size) {
                         R_TRY(svc::SetUnsafeLimit(boost_size));
                         R_ABORT_UNLESS(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
-                    } else {
+                    }  else if (boost_size > cur_boost_size) {
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
                         R_ABORT_UNLESS(svc::SetUnsafeLimit(boost_size));
+                    } else {
+                        /* If the boost size is equal, there's nothing to do. */
                     }
                 } else {
                     const u64 new_sys_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_System] + boost_size;
-                    if (boost_size < GetCurrentSystemMemoryBoostSize()) {
+                    if (boost_size < cur_boost_size) {
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
                         R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                    } else if (boost_size > cur_boost_size) {
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
                     } else {
-                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size));
+                        /* If the boost size is equal, there's nothing to do. */
-                        R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_System,      new_sys_size));
                     }
                 }