ams: may as well test removal of CRTP from Result

well, this sure is late, whoops

config/common.mk

@@ -44,7 +44,7 @@ else ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
 export ATMOSPHERE_CFLAGS += -Wno-c99-designator -Wno-gnu-alignof-expression -Wno-unused-private-field
 endif
 
-export ATMOSPHERE_CXXFLAGS := -fno-rtti -fno-exceptions -std=gnu++20 -Wno-invalid-offsetof
+export ATMOSPHERE_CXXFLAGS := -fno-rtti -fno-exceptions -std=gnu++23 -Wno-invalid-offsetof
 export ATMOSPHERE_ASFLAGS  :=
 
 

libstratosphere/include/stratosphere/fssystem/fssystem_crypto_configuration.hpp

@@ -16,6 +16,7 @@
 #pragma once
 #include <vapours.hpp>
 #include <stratosphere/fssystem/fssystem_nca_file_system_driver.hpp>
+#include <stratosphere/ldr/ldr_platform_id.hpp>
 
 namespace ams::fssystem {
 
@@ -25,10 +26,13 @@ namespace ams::fssystem {
 
     void InvalidateHardwareAesKey();
 
-    const u8 *GetAcidSignatureKeyModulus(bool prod, size_t key_generation);
+    bool IsValidSignatureKeyGeneration(ldr::PlatformId platform, size_t key_generation);
+
+    const u8 *GetAcidSignatureKeyModulus(ldr::PlatformId platform, bool prod, size_t key_generation, bool unk_unused);
+    size_t GetAcidSignatureKeyModulusSize(ldr::PlatformId platform, bool unk_unused);
+
     const u8 *GetAcidSignatureKeyPublicExponent();
 
-    constexpr inline size_t AcidSignatureKeyModulusSize        = NcaCryptoConfiguration::Rsa2048KeyModulusSize;
     constexpr inline size_t AcidSignatureKeyPublicExponentSize = NcaCryptoConfiguration::Rsa2048KeyPublicExponentSize;
 
 }

libstratosphere/include/stratosphere/ldr/ldr_platform_id.hpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::ldr {
+
+    /* TODO: Is this really a FS type? What namespace does this actually live inside? */
+    enum PlatformId {
+        PlatformId_Nx = 0,
+    };
+
+}

libstratosphere/include/stratosphere/ldr/ldr_types.hpp

@@ -19,6 +19,7 @@
 #include <stratosphere/ncm/ncm_ids.hpp>
 #include <stratosphere/ncm/ncm_program_location.hpp>
 #include <stratosphere/sf/sf_buffer_tags.hpp>
+#include <stratosphere/ldr/ldr_platform_id.hpp>
 
 namespace ams::ldr {
 
@@ -224,6 +225,7 @@ namespace ams::ldr {
 
             MetaFlag_OptimizeMemoryAllocation       = (1 << 4),
             MetaFlag_DisableDeviceAddressSpaceMerge = (1 << 5),
+            MetaFlag_EnableAliasRegionExtraSize     = (1 << 6),
         };
 
         enum AddressSpaceType {

libstratosphere/source/ams/ams_emummc_api.cpp

@@ -73,7 +73,7 @@ namespace ams::emummc {
             /* Retrieve and cache values. */
             {
 
-                typename std::aligned_storage<2 * (MaxDirLen + 1), os::MemoryPageSize>::type path_storage;
+                alignas(os::MemoryPageSize) std::byte path_storage[2 * (MaxDirLen + 1)];
 
                 struct {
                     char file_path[MaxDirLen + 1];

libstratosphere/source/fs/fs_api.cpp

@@ -23,8 +23,8 @@ namespace ams::fs {
     #if defined(ATMOSPHERE_OS_HORIZON)
     namespace {
 
-        constinit std::aligned_storage_t<0x80> g_fsp_service_object_buffer;
-        constinit std::aligned_storage_t<0x80> g_fsp_ldr_service_object_buffer;
+        alignas(0x10) constinit std::byte g_fsp_service_object_buffer[0x80] = {};
+        alignas(0x10) constinit std::byte g_fsp_ldr_service_object_buffer[0x80] = {};
         constinit bool g_use_static_fsp_service_object_buffer = false;
         constinit bool g_use_static_fsp_ldr_service_object_buffer = false;
 

libstratosphere/source/fssrv/impl/fssrv_program_info.cpp

@@ -20,7 +20,7 @@ namespace ams::fssrv::impl {
 
     namespace {
 
-        constinit std::aligned_storage<0x80>::type g_static_buffer_for_program_info_for_initial_process = {};
+        alignas(0x10) constinit std::byte g_static_buffer_for_program_info_for_initial_process[0x80] = {};
 
         template<typename T>
         class StaticAllocatorForProgramInfoForInitialProcess : public std::allocator<T> {

libstratosphere/source/fssystem/fssystem_crypto_configuration.cpp

@@ -22,9 +22,11 @@ namespace ams::fssystem {
 
         constexpr inline const size_t KeySize = crypto::AesDecryptor128::KeySize;
 
-        constexpr inline const size_t AcidSignatureKeyGenerationMax = 1;
+        constexpr inline const size_t NxAcidSignatureKeyGenerationMax = 1;
 
-        constexpr inline const u8 AcidSignatureKeyModulusDev[AcidSignatureKeyGenerationMax + 1][AcidSignatureKeyModulusSize] = {
+        constexpr inline const size_t NxAcidSignatureKeyModulusSize = NcaCryptoConfiguration::Rsa2048KeyModulusSize;
+
+        constexpr inline const u8 NxAcidSignatureKeyModulusDev[NxAcidSignatureKeyGenerationMax + 1][NxAcidSignatureKeyModulusSize] = {
             {
                 0xD6, 0x34, 0xA5, 0x78, 0x6C, 0x68, 0xCE, 0x5A, 0xC2, 0x37, 0x17, 0xF3, 0x82, 0x45, 0xC6, 0x89,
                 0xE1, 0x2D, 0x06, 0x67, 0xBF, 0xB4, 0x06, 0x19, 0x55, 0x6B, 0x27, 0x66, 0x0C, 0xA4, 0xB5, 0x87,
@@ -63,7 +65,7 @@ namespace ams::fssystem {
             }
         };
 
-        constexpr inline const u8 AcidSignatureKeyModulusProd[AcidSignatureKeyGenerationMax + 1][AcidSignatureKeyModulusSize] = {
+        constexpr inline const u8 NxAcidSignatureKeyModulusProd[NxAcidSignatureKeyGenerationMax + 1][NxAcidSignatureKeyModulusSize] = {
             {
                 0xDD, 0xC8, 0xDD, 0xF2, 0x4E, 0x6D, 0xF0, 0xCA, 0x9E, 0xC7, 0x5D, 0xC7, 0x7B, 0xAD, 0xFE, 0x7D,
                 0x23, 0x89, 0x69, 0xB6, 0xF2, 0x06, 0xA2, 0x02, 0x88, 0xE1, 0x55, 0x91, 0xAB, 0xCB, 0x4D, 0x50,
@@ -102,7 +104,7 @@ namespace ams::fssystem {
             }
         };
 
-        static_assert(sizeof(AcidSignatureKeyModulusProd) == sizeof(AcidSignatureKeyModulusDev));
+        static_assert(sizeof(NxAcidSignatureKeyModulusProd) == sizeof(NxAcidSignatureKeyModulusDev));
 
         constexpr inline const u8 AcidSignatureKeyPublicExponent[] = {
             0x01, 0x00, 0x01
@@ -295,10 +297,36 @@ namespace ams::fssystem {
         }
     }
 
-    const u8 *GetAcidSignatureKeyModulus(bool prod, size_t key_generation) {
-        AMS_ASSERT(key_generation <= AcidSignatureKeyGenerationMax);
-        const size_t used_keygen = (key_generation % (AcidSignatureKeyGenerationMax + 1));
-        return prod ? AcidSignatureKeyModulusProd[used_keygen] : AcidSignatureKeyModulusDev[used_keygen];
+    bool IsValidSignatureKeyGeneration(ldr::PlatformId platform, size_t key_generation) {
+        switch (platform) {
+            case ldr::PlatformId_Nx:
+                return key_generation <= NxAcidSignatureKeyGenerationMax;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    const u8 *GetAcidSignatureKeyModulus(ldr::PlatformId platform, bool prod, size_t key_generation, bool unk_unused) {
+        AMS_ASSERT(IsValidSignatureKeyGeneration(platform, key_generation));
+        AMS_UNUSED(unk_unused);
+
+        switch (platform) {
+            case ldr::PlatformId_Nx:
+                {
+                    const size_t used_keygen = (key_generation % (NxAcidSignatureKeyGenerationMax + 1));
+                    return prod ? NxAcidSignatureKeyModulusProd[used_keygen] : NxAcidSignatureKeyModulusDev[used_keygen];
+                }
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    size_t GetAcidSignatureKeyModulusSize(ldr::PlatformId platform, bool unk_unused) {
+        AMS_UNUSED(unk_unused);
+
+        switch (platform) {
+            case ldr::PlatformId_Nx:
+                return NxAcidSignatureKeyModulusSize;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
     }
 
     const u8 *GetAcidSignatureKeyPublicExponent() {

libstratosphere/source/htc/server/rpc/htc_rpc_task_table.hpp

@@ -41,7 +41,7 @@ namespace ams::htc::server::rpc {
             #else
             static constexpr size_t MaxTaskSize = 0xE1D8;
             #endif
-            using TaskStorage = typename std::aligned_storage<MaxTaskSize, alignof(void *)>::type;
+            struct TaskStorage { alignas(alignof(void *)) std::byte _storage[MaxTaskSize]; };
         private:
             bool m_valid[MaxRpcCount]{};
             TaskStorage m_storages[MaxRpcCount]{};

libstratosphere/source/osdbg/impl/osdbg_types.hpp

@@ -19,9 +19,13 @@
 namespace ams::osdbg::impl {
 
     template<size_t Size, int NumPointers, size_t Alignment>
-    using AlignedStorageIlp32 = typename std::aligned_storage<Size + NumPointers * sizeof(u32), Alignment>::type;
+    struct AlignedStorageIlp32 {
+        alignas(Alignment) std::byte _storage[Size + NumPointers * sizeof(u32)];
+    };
 
     template<size_t Size, int NumPointers, size_t Alignment>
-    using AlignedStorageLp64 = typename std::aligned_storage<Size + NumPointers * sizeof(u64), Alignment>::type;
+    struct AlignedStorageLp64 {
+        alignas(Alignment) std::byte _storage[Size + NumPointers * sizeof(u64)];
+    };
 
 }

libvapours/include/vapours/results/loader_results.hpp

@@ -34,6 +34,8 @@ namespace ams::ldr {
     R_DEFINE_ERROR_RESULT(InvalidAcidSignature,  11);
     R_DEFINE_ERROR_RESULT(InvalidNcaSignature,   12);
 
+    R_DEFINE_ERROR_RESULT(InvalidPlatformId,     14);
+
     R_DEFINE_ERROR_RESULT(OutOfAddressSpace,            51);
     R_DEFINE_ERROR_RESULT(InvalidNroImage,              52);
     R_DEFINE_ERROR_RESULT(InvalidNrrImage,              53);

libvapours/include/vapours/results/results_common.hpp

@@ -85,14 +85,13 @@ namespace ams {
         };
 
         /* Use CRTP for Results. */
-        template<typename Self>
         class ResultBase {
             public:
                 using BaseType = typename ResultTraits::BaseType;
                 static constexpr BaseType SuccessValue = ResultTraits::SuccessValue;
             public:
-                constexpr ALWAYS_INLINE BaseType GetModule() const { return ResultTraits::GetModuleFromValue(static_cast<const Self *>(this)->GetValue()); }
-                constexpr ALWAYS_INLINE BaseType GetDescription() const { return ResultTraits::GetDescriptionFromValue(static_cast<const Self *>(this)->GetValue()); }
+                constexpr ALWAYS_INLINE BaseType GetModule(this auto const &self) { return ResultTraits::GetModuleFromValue(self.GetValue()); }
+                constexpr ALWAYS_INLINE BaseType GetDescription(this auto const &self) { return ResultTraits::GetDescriptionFromValue(self.GetValue()); }
         };
 
         class ResultInternalAccessor;
@@ -101,10 +100,10 @@ namespace ams {
 
     class ResultSuccess;
 
-    class Result final : public result::impl::ResultBase<Result> {
+    class Result final : public result::impl::ResultBase {
         friend class result::impl::ResultInternalAccessor;
         public:
-            using Base = typename result::impl::ResultBase<Result>;
+            using Base = typename result::impl::ResultBase;
         private:
             typename Base::BaseType m_value;
         private:
@@ -157,9 +156,9 @@ namespace ams {
 
     }
 
-    class ResultSuccess final : public result::impl::ResultBase<ResultSuccess> {
+    class ResultSuccess final : public result::impl::ResultBase {
         public:
-            using Base = typename result::impl::ResultBase<ResultSuccess>;
+            using Base = typename result::impl::ResultBase;
         public:
             constexpr ALWAYS_INLINE operator Result() const { return result::impl::MakeResult(Base::SuccessValue); }
             static constexpr ALWAYS_INLINE bool CanAccept(Result result) { return result.IsSuccess(); }
@@ -189,9 +188,9 @@ namespace ams {
     namespace result::impl {
 
         template<ResultTraits::BaseType _Module, ResultTraits::BaseType _Description>
-        class ResultErrorBase : public ResultBase<ResultErrorBase<_Module, _Description>> {
+        class ResultErrorBase : public ResultBase {
             public:
-                using Base = typename result::impl::ResultBase<ResultErrorBase<_Module, _Description>>;
+                using Base = typename result::impl::ResultBase;
                 static constexpr typename Base::BaseType Module = _Module;
                 static constexpr typename Base::BaseType Description = _Description;
                 static constexpr typename Base::BaseType Value = ResultTraits::MakeStaticValue<Module, Description>::value;

libvapours/include/vapours/svc/codegen/impl/svc_codegen_impl_code_generator.hpp

@@ -201,7 +201,7 @@ namespace ams::svc::codegen::impl {
                 } else if constexpr (Size == 8) {
                     __asm__ __volatile__("ldr     x%c[r], [sp, %c[offset]]" :: [r]"i"(Reg), [offset]"i"(Offset) : "memory");
                 } else {
-                    static_assert(Size != Size);
+                    static_assert(false, "Invalid Size");
                 }
             }
 
@@ -212,7 +212,7 @@ namespace ams::svc::codegen::impl {
                 } else if constexpr (Size == 8) {
                     __asm__ __volatile__("ldp     x%c[r0], x%c[r1], [sp, %c[offset]]" :: [r0]"i"(Reg0), [r1]"i"(Reg1), [offset]"i"(Offset) : "memory");
                 } else {
-                    static_assert(Size != Size);
+                    static_assert(false, "Invalid Size");
                 }
             }
 
@@ -223,7 +223,7 @@ namespace ams::svc::codegen::impl {
                 } else if constexpr (Size == 8) {
                     __asm__ __volatile__("str     x%c[r], [sp, %c[offset]]" :: [r]"i"(Reg), [offset]"i"(Offset) : "memory");
                 } else {
-                    static_assert(Size != Size);
+                    static_assert(false, "Invalid Size");
                 }
             }
 
@@ -234,7 +234,7 @@ namespace ams::svc::codegen::impl {
                 } else if constexpr (Size == 8) {
                     __asm__ __volatile__("stp     x%c[r0], x%c[r1], [sp, %c[offset]]" :: [r0]"i"(Reg0), [r1]"i"(Reg1), [offset]"i"(Offset) : "memory");
                 } else {
-                    static_assert(Size != Size);
+                    static_assert(false, "Invalid Size");
                 }
             }
 

libvapours/include/vapours/svc/codegen/impl/svc_codegen_impl_layout_conversion.hpp

@@ -461,7 +461,7 @@ namespace ams::svc::codegen::impl {
                 if constexpr (CodeGenKind == CodeGenerationKind::SvcInvocationToKernelProcedure) {
                     return Operation::ImplType::template CanGenerateCodeForSvcInvocationToKernelProcedure<Operation>(allocator);
                 } else {
-                    static_assert(CodeGenKind != CodeGenKind, "Invalid CodeGenerationKind");
+                    static_assert(false, "Invalid CodeGenerationKind");
                 }
             }
 
@@ -474,7 +474,7 @@ namespace ams::svc::codegen::impl {
                 } else if constexpr (CodeGenKind == CodeGenerationKind::KernelProcedureToSvcInvocation) {
                     Operation::ImplType::template GenerateCodeForKernelProcedureToSvcInvocation<Operation>(mcg);
                 } else {
-                    static_assert(CodeGenKind != CodeGenKind, "Invalid CodeGenerationKind");
+                    static_assert(false, "Invalid CodeGenerationKind");
                 }
             }
     };

libvapours/include/vapours/svc/codegen/impl/svc_codegen_impl_meta_code.hpp

@@ -127,7 +127,7 @@ namespace ams::svc::codegen::impl {
         META_CODE_OPERATION_KIND_GENERATE_CODE(Pack)
         META_CODE_OPERATION_KIND_GENERATE_CODE(Unpack)
         META_CODE_OPERATION_KIND_GENERATE_CODE(LoadStackAddress)
-        else { static_assert(Kind != Kind, "Unknown MetaOperationKind"); }
+        else { static_assert(false, "Unknown MetaOperationKind"); }
         #undef META_CODE_OPERATION_KIND_GENERATE_CODE
     }
 

libvapours/include/vapours/util/arch/arm64/util_atomic.hpp

@@ -157,7 +157,7 @@ namespace ams::util {
             } else if constexpr (Order == std::memory_order_acq_rel || Order == std::memory_order_seq_cst) {
                 return ::ams::util::impl::LoadAcquireExclusiveForAtomic(p);
             } else {
-                static_assert(Order != Order, "Invalid memory order");
+                static_assert(false, "Invalid memory order");
             }
         }
 
@@ -172,7 +172,7 @@ namespace ams::util {
             } else if constexpr (Order == std::memory_order_acq_rel || Order == std::memory_order_seq_cst) {
                 return ::ams::util::impl::StoreReleaseExclusiveForAtomic(p, s);
             } else {
-                static_assert(Order != Order, "Invalid memory order");
+                static_assert(false, "Invalid memory order");
             }
         }
 

libvapours/include/vapours/util/util_typed_storage.hpp

@@ -22,7 +22,7 @@ namespace ams::util {
 
     template<typename T, size_t Size = sizeof(T), size_t Align = alignof(T)>
     struct TypedStorage {
-        typename std::aligned_storage<Size, Align>::type _storage;
+        alignas(Align) std::byte _storage[Size];
     };
 
     template<typename T>