[cmake] enable clang-cl and WoA builds (#348)

Compilation and CMake fixes for both Windows on ARM and clang-cl, meaning Windows can now be built on both MSVC and clang on both amd64 and aarch64.

Compiling on clang is *dramatically* faster so this should be useful for CI.

Co-authored-by: crueter <crueter@eden-emu.dev>
Co-authored-by: crueter <crueter@crueter.xyz>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/348
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: crueter <crueter@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

src/core/hle/service/acc/acc.cpp

@@ -72,7 +72,7 @@ static void SanitizeJPEGImageSize(std::vector<u8>& image) {
         }
     }
 
-    image.resize(std::min(image.size(), max_jpeg_image_size));
+    image.resize((std::min)(image.size(), max_jpeg_image_size));
 }
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {

src/core/hle/service/am/frontend/applet_cabinet.cpp

@@ -118,7 +118,7 @@ void Cabinet::DisplayCompleted(bool apply_changes, std::string_view amiibo_name)
     case Service::NFP::CabinetMode::StartNicknameAndOwnerSettings: {
         Service::NFP::RegisterInfoPrivate register_info{};
         std::memcpy(register_info.amiibo_name.data(), amiibo_name.data(),
-                    std::min(amiibo_name.size(), register_info.amiibo_name.size() - 1));
+                    (std::min)(amiibo_name.size(), register_info.amiibo_name.size() - 1));
         register_info.mii_store_data.BuildRandom(Mii::Age::All, Mii::Gender::All, Mii::Race::All);
         register_info.mii_store_data.SetNickname({u'y', u'u', u'z', u'u'});
         nfp_device->SetRegisterInfoPrivate(register_info);

src/core/hle/service/am/frontend/applet_controller.cpp

@@ -31,7 +31,7 @@ static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
     npad_style_set.raw = private_arg.style_set;
 
     return {
-        .min_players = std::max(s8{1}, header.player_count_min),
+        .min_players = (std::max)(s8{1}, header.player_count_min),
         .max_players = header.player_count_max,
         .keep_controllers_connected = header.enable_take_over_connection,
         .enable_single_mode = header.enable_single_mode,

src/core/hle/service/am/service/application_accessor.cpp

@@ -115,7 +115,7 @@ Result IApplicationAccessor::GetApplicationControlProperty(
     R_TRY(system.GetARPManager().GetControlProperty(&nacp, m_applet->program_id));
 
     std::memcpy(out_control_property.data(), nacp.data(),
-                std::min(out_control_property.size(), nacp.size()));
+                (std::min)(out_control_property.size(), nacp.size()));
 
     R_SUCCEED();
 }

src/core/hle/service/am/service/application_functions.cpp

@@ -216,7 +216,7 @@ Result IApplicationFunctions::GetDisplayVersion(Out<DisplayVersion> out_display_
     if (res.first != nullptr) {
         const auto& version = res.first->GetVersionString();
         std::memcpy(out_display_version->string.data(), version.data(),
-                    std::min(version.size(), out_display_version->string.size()));
+                    (std::min)(version.size(), out_display_version->string.size()));
     } else {
         static constexpr char default_version[]{"1.0.0"};
         std::memcpy(out_display_version->string.data(), default_version, sizeof(default_version));
@@ -284,7 +284,7 @@ Result IApplicationFunctions::GetCacheStorageMax(Out<u32> out_cache_storage_inde
     R_TRY(system.GetARPManager().GetControlProperty(&nacp, m_applet->program_id));
 
     auto raw_nacp = std::make_unique<FileSys::RawNACP>();
-    std::memcpy(raw_nacp.get(), nacp.data(), std::min(sizeof(*raw_nacp), nacp.size()));
+    std::memcpy(raw_nacp.get(), nacp.data(), (std::min)(sizeof(*raw_nacp), nacp.size()));
 
     *out_cache_storage_index_max = static_cast<u32>(raw_nacp->cache_storage_max_index);
     *out_max_journal_size = static_cast<u64>(raw_nacp->cache_storage_data_and_journal_max_size);

src/core/hle/service/am/service/library_applet_self_accessor.cpp

@@ -162,7 +162,7 @@ Result ILibraryAppletSelfAccessor::GetMainAppletApplicationControlProperty(
         system.GetARPManager().GetControlProperty(&nacp, application.application_id);
 
     if (R_SUCCEEDED(result)) {
-        std::memcpy(out_nacp->data(), nacp.data(), std::min(nacp.size(), out_nacp->size()));
+        std::memcpy(out_nacp->data(), nacp.data(), (std::min)(nacp.size(), out_nacp->size()));
     }
 
     R_RETURN(result);

src/core/hle/service/bcat/bcat_service.cpp

@@ -102,7 +102,7 @@ Result IBcatService::SetPassphrase(u64 application_id,
 
     Passphrase passphrase{};
     std::memcpy(passphrase.data(), passphrase_buffer.data(),
-                std::min(passphrase.size(), passphrase_buffer.size()));
+                (std::min)(passphrase.size(), passphrase_buffer.size()));
 
     backend.SetPassphrase(application_id, passphrase);
     R_SUCCEED();

src/core/hle/service/bcat/delivery_cache_directory_service.cpp

@@ -57,12 +57,12 @@ Result IDeliveryCacheDirectoryService::Read(
     R_UNLESS(current_dir != nullptr, ResultNoOpenEntry);
 
     const auto files = current_dir->GetFiles();
-    *out_count = static_cast<s32>(std::min(files.size(), out_buffer.size()));
+    *out_count = static_cast<s32>((std::min)(files.size(), out_buffer.size()));
     std::transform(files.begin(), files.begin() + *out_count, out_buffer.begin(),
                    [](const auto& file) {
                        FileName name{};
                        std::memcpy(name.data(), file->GetName().data(),
-                                   std::min(file->GetName().size(), name.size()));
+                                   (std::min)(file->GetName().size(), name.size()));
                        return DeliveryCacheDirectoryEntry{name, file->GetSize(), DigestFile(file)};
                    });
     R_SUCCEED();

src/core/hle/service/bcat/delivery_cache_storage_service.cpp

@@ -47,7 +47,7 @@ Result IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory(
     LOG_DEBUG(Service_BCAT, "called, size={:016X}", out_directories.size());
 
     *out_directory_count =
-        static_cast<s32>(std::min(out_directories.size(), entries.size() - next_read_index));
+        static_cast<s32>((std::min)(out_directories.size(), entries.size() - next_read_index));
     memcpy(out_directories.data(), entries.data() + next_read_index,
            *out_directory_count * sizeof(DirectoryName));
     next_read_index += *out_directory_count;

src/core/hle/service/cmif_serialization.h

@@ -304,7 +304,7 @@ void ReadInArgument(bool is_domain, CallArguments& args, const u8* raw_data, HLE
                 buffer = ctx.ReadBufferX(InBufferIndex);
             }
 
-            std::memcpy(&std::get<ArgIndex>(args), buffer.data(), std::min(BufferSize, buffer.size()));
+            std::memcpy(&std::get<ArgIndex>(args), buffer.data(), (std::min)(BufferSize, buffer.size()));
 
             return ReadInArgument<MethodArguments, CallArguments, PrevAlign, DataOffset, HandleIndex, InBufferIndex + 1, OutBufferIndex, RawDataFinished, ArgIndex + 1>(is_domain, args, raw_data, ctx, temp);
         } else if constexpr (ArgumentTraits<ArgType>::Type == ArgumentType::InBuffer) {

src/core/hle/service/es/es.cpp

@@ -203,7 +203,7 @@ private:
         std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
                        [](const auto& pair) { return pair.first; });
 
-        out_entries = std::min(ids.size(), out_entries);
+        out_entries = (std::min)(ids.size(), out_entries);
         ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
 
         IPC::ResponseBuilder rb{ctx, 3};
@@ -225,7 +225,7 @@ private:
         std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
                        [](const auto& pair) { return pair.first; });
 
-        out_entries = std::min(ids.size(), out_entries);
+        out_entries = (std::min)(ids.size(), out_entries);
         ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
 
         IPC::ResponseBuilder rb{ctx, 3};

src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp

@@ -44,7 +44,7 @@ Result ISaveDataInfoReader::ReadSaveDataInfo(
     const u64 count_entries = out_entries.size();
 
     // Cap at total number of entries.
-    const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
+    const u64 actual_entries = (std::min)(count_entries, info.size() - next_entry_index);
 
     // Determine data start and end
     const auto* begin = reinterpret_cast<u8*>(info.data() + next_entry_index);

src/core/hle/service/glue/notif.cpp

@@ -67,7 +67,7 @@ Result NotificationServiceImpl::ListAlarmSettings(s32* out_count,
                                                   std::span<AlarmSetting> out_alarms) {
     LOG_INFO(Service_NOTIF, "called, alarm_count={}", alarms.size());
 
-    const auto count = std::min(out_alarms.size(), alarms.size());
+    const auto count = (std::min)(out_alarms.size(), alarms.size());
     for (size_t i = 0; i < count; i++) {
         out_alarms[i] = alarms[i];
     }
@@ -90,7 +90,7 @@ Result NotificationServiceImpl::LoadApplicationParameter(u32* out_size,
 
     LOG_WARNING(Service_NOTIF, "(STUBBED) called, alarm_setting_id={}", alarm_setting_id);
     std::memcpy(out_application_parameter.data(), application_parameter.data(),
-                std::min(sizeof(application_parameter), out_application_parameter.size()));
+                (std::min)(sizeof(application_parameter), out_application_parameter.size()));
 
     *out_size = static_cast<u32>(application_parameter.size());
     R_SUCCEED();

src/core/hle/service/glue/time/manager.cpp

@@ -29,7 +29,7 @@ static s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
     };
 
     s16 month_s16{calendar.month};
-    s8 month{static_cast<s8>(((month_s16 * 43) & ~std::numeric_limits<s16>::max()) +
+    s8 month{static_cast<s8>(((month_s16 * 43) & ~(std::numeric_limits<s16>::max)()) +
                              ((month_s16 * 43) >> 9))};
     s8 month_index{static_cast<s8>(calendar.month - 12 * month)};
     if (month_index == 0) {
@@ -71,13 +71,13 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
 
     Service::PSC::Time::LocationName configured_name{};
     std::memcpy(configured_name.data(), configured_zone.data(),
-                std::min(configured_name.size(), configured_zone.size()));
+                (std::min)(configured_name.size(), configured_zone.size()));
 
     if (!time_zone_binary.IsValid(configured_name)) {
         configured_zone = Common::TimeZone::FindSystemTimeZone();
         configured_name = {};
         std::memcpy(configured_name.data(), configured_zone.data(),
-                    std::min(configured_name.size(), configured_zone.size()));
+                    (std::min)(configured_name.size(), configured_zone.size()));
     }
 
     ASSERT_MSG(time_zone_binary.IsValid(configured_name), "Invalid time zone {}!",

src/core/hle/service/hid/hid_debug_server.cpp

@@ -178,7 +178,7 @@ Result IHidDebugServer::SetTouchScreenAutoPilotState(
     AutoPilotState auto_pilot{};
 
     auto_pilot.count =
-        static_cast<u64>(std::min(auto_pilot_buffer.size(), auto_pilot.state.size()));
+        static_cast<u64>((std::min)(auto_pilot_buffer.size(), auto_pilot.state.size()));
     memcpy(auto_pilot.state.data(), auto_pilot_buffer.data(),
            auto_pilot.count * sizeof(TouchState));
 

src/core/hle/service/jit/jit_context.cpp

@@ -107,7 +107,7 @@ public:
 
     void AddTicks(u64 ticks) override {}
     u64 GetTicksRemaining() override {
-        return std::numeric_limits<u32>::max();
+        return (std::numeric_limits<u32>::max)();
     }
     u64 GetCNTPCT() override {
         return 0;

src/core/hle/service/ldn/ldn_types.h

@@ -170,7 +170,7 @@ struct Ssid {
     Ssid() = default;
 
     constexpr explicit Ssid(std::string_view data) {
-        length = static_cast<u8>(std::min(data.size(), SsidLengthMax));
+        length = static_cast<u8>((std::min)(data.size(), SsidLengthMax));
         raw = {};
         data.copy(raw.data(), length);
         raw[length] = 0;

src/core/hle/service/lm/lm.cpp

@@ -180,7 +180,7 @@ private:
         if (length == 0) {
             return std::nullopt;
         }
-        const auto length_to_read = std::min(length, data.size() - offset);
+        const auto length_to_read = (std::min)(length, data.size() - offset);
 
         std::string output(length_to_read, '\0');
         std::memcpy(output.data(), data.data() + offset, length_to_read);

src/core/hle/service/nfc/common/device.cpp

@@ -978,7 +978,7 @@ Result NfcDevice::GetApplicationArea(std::span<u8> data) const {
     }
 
     memcpy(data.data(), tag_data.application_area.data(),
-           std::min(data.size(), sizeof(NFP::ApplicationArea)));
+           (std::min)(data.size(), sizeof(NFP::ApplicationArea)));
 
     return ResultSuccess;
 }

src/core/hle/service/nifm/nifm.cpp

@@ -613,7 +613,7 @@ void IGeneralService::EnumerateNetworkInterfaces(HLERequestContext& ctx) {
 
     const size_t guest_bytes = ctx.GetWriteBufferSize();
     if (guest_bytes && !blob.empty())
-        ctx.WriteBuffer(blob.data(), std::min(guest_bytes, blob.size()));
+        ctx.WriteBuffer(blob.data(), (std::min)(guest_bytes, blob.size()));
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
@@ -639,7 +639,7 @@ void IGeneralService::EnumerateNetworkProfiles(HLERequestContext& ctx) {
 
     const size_t guest_sz = ctx.GetWriteBufferSize();
     if (guest_sz && uuids.size()) {
-        const size_t to_copy = std::min(guest_sz, uuids.size() * sizeof(u128));
+        const size_t to_copy = (std::min)(guest_sz, uuids.size() * sizeof(u128));
         ctx.WriteBuffer(uuids.data(), to_copy);
     }
 

src/core/hle/service/ns/application_manager_interface.cpp

@@ -410,7 +410,7 @@ Result IApplicationManagerInterface::IsAnyApplicationEntityInstalled(
 Result IApplicationManagerInterface::GetApplicationView(
     OutArray<ApplicationView, BufferAttr_HipcMapAlias> out_application_views,
     InArray<u64, BufferAttr_HipcMapAlias> application_ids) {
-    const auto size = std::min(out_application_views.size(), application_ids.size());
+    const auto size = (std::min)(out_application_views.size(), application_ids.size());
     LOG_WARNING(Service_NS, "(STUBBED) called, size={}", application_ids.size());
 
     for (size_t i = 0; i < size; i++) {
@@ -428,7 +428,7 @@ Result IApplicationManagerInterface::GetApplicationView(
 Result IApplicationManagerInterface::GetApplicationViewWithPromotionInfo(
     OutArray<ApplicationViewWithPromotionInfo, BufferAttr_HipcMapAlias> out_application_views,
     InArray<u64, BufferAttr_HipcMapAlias> application_ids) {
-    const auto size = std::min(out_application_views.size(), application_ids.size());
+    const auto size = (std::min)(out_application_views.size(), application_ids.size());
     LOG_WARNING(Service_NS, "(STUBBED) called, size={}", application_ids.size());
 
     for (size_t i = 0; i < size; i++) {

src/core/hle/service/ns/platform_service_manager.cpp

@@ -254,7 +254,7 @@ Result IPlatformServiceManager::GetSharedFontInOrderOfPriority(
     constexpr size_t MaxElementCount = 6;
 
     // TODO(ogniK): Have actual priority order
-    const auto max_size = std::min({MaxElementCount, out_font_codes.size(), out_font_offsets.size(),
+    const auto max_size = (std::min)({MaxElementCount, out_font_codes.size(), out_font_offsets.size(),
                                     out_font_sizes.size(), impl->shared_font_regions.size()});
 
     for (size_t i = 0; i < max_size; i++) {

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -504,7 +504,7 @@ NvResult nvhost_as_gpu::GetVARegions3(IoctlGetVaRegions& params, std::span<VaReg
 
     GetVARegionsImpl(params);
 
-    const size_t num_regions = std::min(params.regions.size(), regions.size());
+    const size_t num_regions = (std::min)(params.regions.size(), regions.size());
     for (size_t i = 0; i < num_regions; i++) {
         regions[i] = params.regions[i];
     }

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -197,12 +197,12 @@ private:
 
     struct VM {
         static constexpr u32 YUZU_PAGESIZE{0x1000};
-        static constexpr u32 PAGE_SIZE_BITS{std::countr_zero(YUZU_PAGESIZE)};
+        static constexpr u32 PAGE_SIZE_BITS{static_cast<u32>(std::countr_zero<u32>(YUZU_PAGESIZE))};
 
         static constexpr u32 SUPPORTED_BIG_PAGE_SIZES{0x30000};
         static constexpr u32 DEFAULT_BIG_PAGE_SIZE{0x20000};
         u32 big_page_size{DEFAULT_BIG_PAGE_SIZE};
-        u32 big_page_size_bits{std::countr_zero(DEFAULT_BIG_PAGE_SIZE)};
+        u32 big_page_size_bits{static_cast<u32>(std::countr_zero<u32>(DEFAULT_BIG_PAGE_SIZE))};
 
         static constexpr u32 VA_START_SHIFT{10};
         static constexpr u64 DEFAULT_VA_SPLIT{1ULL << 34};

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -139,7 +139,7 @@ NvResult nvhost_nvdec_common::GetWaitbase(IoctlGetWaitbase& params) {
 
 NvResult nvhost_nvdec_common::MapBuffer(IoctlMapBuffer& params, std::span<MapBufferEntry> entries,
                                         DeviceFD fd) {
-    const size_t num_entries = std::min(params.num_entries, static_cast<u32>(entries.size()));
+    const size_t num_entries = (std::min)(params.num_entries, static_cast<u32>(entries.size()));
     for (size_t i = 0; i < num_entries; i++) {
         DAddr pin_address = nvmap.PinHandle(entries[i].map_handle, true);
         entries[i].map_address = static_cast<u32>(pin_address);
@@ -150,7 +150,7 @@ NvResult nvhost_nvdec_common::MapBuffer(IoctlMapBuffer& params, std::span<MapBuf
 
 NvResult nvhost_nvdec_common::UnmapBuffer(IoctlMapBuffer& params,
                                           std::span<MapBufferEntry> entries) {
-    const size_t num_entries = std::min(params.num_entries, static_cast<u32>(entries.size()));
+    const size_t num_entries = (std::min)(params.num_entries, static_cast<u32>(entries.size()));
     for (size_t i = 0; i < num_entries; i++) {
         nvmap.UnpinHandle(entries[i].map_handle);
         entries[i] = {};

src/core/hle/service/nvnflinger/buffer_queue_consumer.cpp

@@ -328,7 +328,7 @@ void BufferQueueConsumer::Transact(u32 code, std::span<const u8> parcel_data,
 
     const auto serialized = parcel_out.Serialize();
     std::memcpy(parcel_reply.data(), serialized.data(),
-                std::min(parcel_reply.size(), serialized.size()));
+                (std::min)(parcel_reply.size(), serialized.size()));
 }
 
 Kernel::KReadableEvent* BufferQueueConsumer::GetNativeHandle(u32 type_id) {

src/core/hle/service/nvnflinger/buffer_queue_core.cpp

@@ -47,7 +47,7 @@ s32 BufferQueueCore::GetMinMaxBufferCountLocked(bool async) const {
 
 s32 BufferQueueCore::GetMaxBufferCountLocked(bool async) const {
     const auto min_buffer_count = GetMinMaxBufferCountLocked(async);
-    auto max_buffer_count = std::max(default_max_buffer_count, min_buffer_count);
+    auto max_buffer_count = (std::max)(default_max_buffer_count, min_buffer_count);
 
     if (override_max_buffer_count != 0) {
         ASSERT(override_max_buffer_count >= min_buffer_count);

src/core/hle/service/nvnflinger/buffer_queue_producer.cpp

@@ -942,7 +942,7 @@ void BufferQueueProducer::Transact(u32 code, std::span<const u8> parcel_data,
 
         std::scoped_lock lock{core->mutex};
 
-        auto buffer_history_count = std::min(parcel_in.Read<s32>(), (s32)core->history.size());
+        auto buffer_history_count = (std::min)(parcel_in.Read<s32>(), (s32)core->history.size());
 
         if (buffer_history_count <= 0) {
             parcel_out.Write(Status::BadValue);
@@ -978,7 +978,7 @@ void BufferQueueProducer::Transact(u32 code, std::span<const u8> parcel_data,
 
     const auto serialized = parcel_out.Serialize();
     std::memcpy(parcel_reply.data(), serialized.data(),
-                std::min(parcel_reply.size(), serialized.size()));
+                (std::min)(parcel_reply.size(), serialized.size()));
 }
 
 

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -101,7 +101,7 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
         // only swap intervals of 0, 1 and 2 have been observed, but if 3 were
         // to be introduced, this would cause an issue.
         if (swap_interval) {
-            swap_interval = std::min(*swap_interval, item_swap_interval);
+            swap_interval = (std::min)(*swap_interval, item_swap_interval);
         } else {
             swap_interval = item_swap_interval;
         }

src/core/hle/service/psc/time/common.h

@@ -138,12 +138,12 @@ constexpr inline std::chrono::nanoseconds ConvertToTimeSpan(s64 ticks) {
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
 
     constexpr s64 max{Common::WallClock::CNTFRQ *
-                      (std::numeric_limits<s64>::max() / one_second_ns)};
+                      ((std::numeric_limits<s64>::max)() / one_second_ns)};
 
     if (ticks > max) {
-        return std::chrono::nanoseconds(std::numeric_limits<s64>::max());
+        return std::chrono::nanoseconds((std::numeric_limits<s64>::max)());
     } else if (ticks < -max) {
-        return std::chrono::nanoseconds(std::numeric_limits<s64>::min());
+        return std::chrono::nanoseconds((std::numeric_limits<s64>::min)());
     }
 
     auto a{ticks / Common::WallClock::CNTFRQ * one_second_ns};
@@ -156,9 +156,9 @@ constexpr inline Result GetSpanBetweenTimePoints(s64* out_seconds, const SteadyC
                                                  const SteadyClockTimePoint& b) {
     R_UNLESS(out_seconds, ResultInvalidArgument);
     R_UNLESS(a.IdMatches(b), ResultInvalidArgument);
-    R_UNLESS(a.time_point >= 0 || b.time_point <= a.time_point + std::numeric_limits<s64>::max(),
+    R_UNLESS(a.time_point >= 0 || b.time_point <= a.time_point + (std::numeric_limits<s64>::max)(),
              ResultOverflow);
-    R_UNLESS(a.time_point < 0 || b.time_point >= a.time_point + std::numeric_limits<s64>::min(),
+    R_UNLESS(a.time_point < 0 || b.time_point >= a.time_point + (std::numeric_limits<s64>::min)(),
              ResultOverflow);
 
     *out_seconds = b.time_point - a.time_point;

src/core/hle/service/psc/time/power_state_request_manager.cpp

@@ -17,7 +17,7 @@ PowerStateRequestManager::~PowerStateRequestManager() {
 void PowerStateRequestManager::UpdatePendingPowerStateRequestPriority(u32 priority) {
     std::scoped_lock l{m_mutex};
     if (m_has_pending_request) {
-        m_pending_request_priority = std::max(m_pending_request_priority, priority);
+        m_pending_request_priority = (std::max)(m_pending_request_priority, priority);
     } else {
         m_pending_request_priority = priority;
         m_has_pending_request = true;

src/core/hle/service/set/settings_server.cpp

@@ -122,8 +122,8 @@ Result ISettingsServer::GetAvailableLanguageCodes(
     Out<s32> out_count, OutArray<LanguageCode, BufferAttr_HipcPointer> out_language_codes) {
     LOG_DEBUG(Service_SET, "called");
 
-    const std::size_t max_amount = std::min(PRE_4_0_0_MAX_ENTRIES, out_language_codes.size());
-    *out_count = static_cast<s32>(std::min(available_language_codes.size(), max_amount));
+    const std::size_t max_amount = (std::min)(PRE_4_0_0_MAX_ENTRIES, out_language_codes.size());
+    *out_count = static_cast<s32>((std::min)(available_language_codes.size(), max_amount));
 
     memcpy(out_language_codes.data(), available_language_codes.data(),
            static_cast<std::size_t>(*out_count) * sizeof(LanguageCode));
@@ -159,8 +159,8 @@ Result ISettingsServer::GetAvailableLanguageCodes2(
     Out<s32> out_count, OutArray<LanguageCode, BufferAttr_HipcMapAlias> language_codes) {
     LOG_DEBUG(Service_SET, "called");
 
-    const std::size_t max_amount = std::min(POST_4_0_0_MAX_ENTRIES, language_codes.size());
-    *out_count = static_cast<s32>(std::min(available_language_codes.size(), max_amount));
+    const std::size_t max_amount = (std::min)(POST_4_0_0_MAX_ENTRIES, language_codes.size());
+    *out_count = static_cast<s32>((std::min)(available_language_codes.size(), max_amount));
 
     memcpy(language_codes.data(), available_language_codes.data(),
            static_cast<std::size_t>(*out_count) * sizeof(LanguageCode));
@@ -233,7 +233,7 @@ Result ISettingsServer::GetDeviceNickName(
     LOG_DEBUG(Service_SET, "called");
 
     const std::size_t string_size =
-        std::min(Settings::values.device_name.GetValue().size(), out_device_name->size());
+        (std::min)(Settings::values.device_name.GetValue().size(), out_device_name->size());
 
     *out_device_name = {};
     memcpy(out_device_name->data(), Settings::values.device_name.GetValue().data(), string_size);

src/core/hle/service/set/system_settings_server.cpp

@@ -533,7 +533,7 @@ Result ISystemSettingsServer::GetEulaVersions(
     LOG_INFO(Service_SET, "called, elements={}", m_system_settings.eula_version_count);
 
     *out_count =
-        std::min(m_system_settings.eula_version_count, static_cast<s32>(out_eula_versions.size()));
+        (std::min)(m_system_settings.eula_version_count, static_cast<s32>(out_eula_versions.size()));
     memcpy(out_eula_versions.data(), m_system_settings.eula_versions.data(),
            static_cast<std::size_t>(*out_count) * sizeof(EulaVersion));
     R_SUCCEED();
@@ -599,7 +599,7 @@ Result ISystemSettingsServer::GetAccountNotificationSettings(
     LOG_INFO(Service_SET, "called, elements={}",
              m_system_settings.account_notification_settings_count);
 
-    *out_count = std::min(m_system_settings.account_notification_settings_count,
+    *out_count = (std::min)(m_system_settings.account_notification_settings_count,
                           static_cast<s32>(out_account_notification_settings.size()));
     memcpy(out_account_notification_settings.data(),
            m_system_settings.account_notification_settings.data(),

src/core/hle/service/sm/sm_controller.cpp

@@ -74,9 +74,9 @@ void Controller::QueryPointerBufferSize(HLERequestContext& ctx) {
     ASSERT(process != nullptr);
 
     u32 buffer_size = process->GetPointerBufferSize();
-    if (buffer_size > std::numeric_limits<u16>::max()) {
+    if (buffer_size > (std::numeric_limits<u16>::max)()) {
         LOG_WARNING(Service, "Pointer buffer size exceeds u16 max, clamping");
-        buffer_size = std::numeric_limits<u16>::max();
+        buffer_size = (std::numeric_limits<u16>::max)();
     }
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -94,9 +94,9 @@ void Controller::SetPointerBufferSize(HLERequestContext& ctx) {
 
     u32 requested_size = rp.PopRaw<u32>();
 
-    if (requested_size > std::numeric_limits<u16>::max()) {
+    if (requested_size > (std::numeric_limits<u16>::max)()) {
         LOG_WARNING(Service, "Requested pointer buffer size too large, clamping to 0xFFFF");
-        requested_size = std::numeric_limits<u16>::max();
+        requested_size = (std::numeric_limits<u16>::max)();
     }
 
     process->SetPointerBufferSize(requested_size);

src/core/hle/service/sockets/bsd.cpp

@@ -45,13 +45,13 @@ bool IsConnectionBased(Type type) {
 template <typename T>
 T GetValue(std::span<const u8> buffer) {
     T t{};
-    std::memcpy(&t, buffer.data(), std::min(sizeof(T), buffer.size()));
+    std::memcpy(&t, buffer.data(), (std::min)(sizeof(T), buffer.size()));
     return t;
 }
 
 template <typename T>
 void PutValue(std::span<u8> buffer, const T& t) {
-    std::memcpy(buffer.data(), &t, std::min(sizeof(T), buffer.size()));
+    std::memcpy(buffer.data(), &t, (std::min)(sizeof(T), buffer.size()));
 }
 
 } // Anonymous namespace

src/core/hle/service/spl/spl_module.cpp

@@ -68,7 +68,7 @@ void Module::Interface::GenerateRandomBytes(HLERequestContext& ctx) {
 
     const std::size_t size = ctx.GetWriteBufferSize();
 
-    std::uniform_int_distribution<u16> distribution(0, std::numeric_limits<u8>::max());
+    std::uniform_int_distribution<u16> distribution(0, (std::numeric_limits<u8>::max)());
     std::vector<u8> data(size);
     std::generate(data.begin(), data.end(), [&] { return static_cast<u8>(distribution(rng)); });
 

src/core/hle/service/ssl/ssl.cpp

@@ -445,7 +445,7 @@ private:
 
     void GetNextAlpnProto(HLERequestContext& ctx) {
         const size_t writable = ctx.GetWriteBufferSize();
-        const size_t to_write = std::min(next_alpn_proto.size(), writable);
+        const size_t to_write = (std::min)(next_alpn_proto.size(), writable);
 
         if (to_write != 0) {
             ctx.WriteBuffer(std::span<const u8>(next_alpn_proto.data(), to_write));

src/core/hle/service/vi/application_display_service.cpp

@@ -192,7 +192,7 @@ Result IApplicationDisplayService::OpenLayer(Out<u64> out_size,
 
     const auto buffer = parcel.Serialize();
     std::memcpy(out_native_window.data(), buffer.data(),
-                std::min(out_native_window.size(), buffer.size()));
+                (std::min)(out_native_window.size(), buffer.size()));
     *out_size = buffer.size();
 
     R_SUCCEED();
@@ -226,7 +226,7 @@ Result IApplicationDisplayService::CreateStrayLayer(
 
     const auto buffer = parcel.Serialize();
     std::memcpy(out_native_window.data(), buffer.data(),
-                std::min(out_native_window.size(), buffer.size()));
+                (std::min)(out_native_window.size(), buffer.size()));
 
     *out_size = buffer.size();