Merge remote-tracking branch 'origin/main' into gc2

Author: LNDF

.github/workflows/build.yml

@@ -104,7 +104,7 @@ jobs:
         if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install -y ninja-build libx11-dev libxext-dev libwayland-dev libdecor-0-dev libxkbcommon-dev libxcursor-dev libxi-dev libxss-dev libxtst-dev libxrandr-dev libxfixes-dev libudev-dev uuid-dev uuid-dev
+          sudo apt-get install -y libc++-dev libc++abi-dev ninja-build libx11-dev libxext-dev libwayland-dev libdecor-0-dev libxkbcommon-dev libxcursor-dev libxi-dev libxss-dev libxtst-dev libxrandr-dev libxfixes-dev libudev-dev uuid-dev uuid-dev
 
       - name: Install dependencies (macOS)
         if: runner.os == 'macOS'
@@ -118,6 +118,7 @@ jobs:
             -DCMAKE_C_COMPILER="${{ matrix.compiler_c }}" \
             -DCMAKE_BUILD_TYPE=Debug \
             -DENABLE_TESTS=ON \
+            ${{ runner.os == 'Linux' && '-DCMAKE_CXX_FLAGS=-stdlib=libc++' || '' }} \
             ${{ runner.os == 'macOS' && '-DCMAKE_OSX_ARCHITECTURES=x86_64' || '' }}
         shell: bash
 
@@ -139,7 +140,7 @@ jobs:
         shell: bash
 
       - name: Run tests with CTest
-        run: ctest --test-dir build --output-on-failure --progress
+        run: ctest --test-dir build --output-on-failure --progress -E 'GcnTest'
         shell: bash
 
   windows-sdl:

src/common/logging/log.cpp

@@ -10,6 +10,9 @@
 #include "common/logging/thread_name_formatter.h"
 #include "common/types.h"
 #include "core/emulator_settings.h"
+#ifdef _WIN32
+#include <Windows.h>
+#endif
 
 namespace Common::Log {
 bool g_should_append = false;
@@ -120,6 +123,42 @@ std::unordered_map<std::string_view, std::shared_ptr<spdlog::logger>> ALL_LOGGER
     {Class::Tty, nullptr},
 };
 
+template <typename T>
+static auto UpdateColorLevels(T sink) {
+#ifdef _WIN32
+    using LogColor = std::uint16_t;
+
+    const auto Grey = FOREGROUND_INTENSITY;
+    const auto Cyan = FOREGROUND_GREEN | FOREGROUND_BLUE;
+    const auto Bright_gray = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+    const auto Bright_yellow = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
+    const auto Bright_red = FOREGROUND_RED | FOREGROUND_INTENSITY;
+    const auto Bright_magenta = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
+#else
+    using LogColor = std::string_view;
+
+#define ESC "\x1b"
+    const auto Grey = ESC "[1;30m";
+    const auto Cyan = ESC "[0;36m";
+    const auto Bright_gray = ESC "[0;37m";
+    const auto Bright_yellow = ESC "[1;33m";
+    const auto Bright_red = ESC "[1;31m";
+    const auto Bright_magenta = ESC "[1;35m";
+#undef ESC
+#endif
+
+    const std::unordered_map<spdlog::level, LogColor> colors{
+        {spdlog::level::trace, Grey},       {spdlog::level::debug, Cyan},
+        {spdlog::level::info, Bright_gray}, {spdlog::level::warn, Bright_yellow},
+        {spdlog::level::err, Bright_red},   {spdlog::level::critical, Bright_magenta}};
+
+    for (const auto& [level, color] : colors) {
+        sink->set_color(level, color);
+    }
+
+    return sink;
+}
+
 void Setup(std::string_view log_filename) {
     static bool already_registered = false;
 
@@ -135,8 +174,9 @@ void Setup(std::string_view log_filename) {
     } else {
         g_console_sink = std::make_shared<spdlog::sinks::msvc_sink_mt>();
     }
+
 #else
-    g_console_sink = std::make_shared<spdlog_stdout>();
+    g_console_sink = UpdateColorLevels(std::make_shared<spdlog_stdout>());
 #endif
 
     g_console_sink->set_formatter(std::make_unique<thread_name_formatter>(UNLIMITED_SIZE));

src/common/logging/thread_name_formatter.h

@@ -14,6 +14,13 @@
 namespace Common::Log {
 static constexpr unsigned long long UNLIMITED_SIZE = 0;
 
+static constexpr std::array level_string_views{"Trace", "Debug",    "Info", "Warning",
+                                               "Error", "Critical", "Off"};
+
+[[nodiscard]] static constexpr std::string_view to_string_view(spdlog::level lvl) noexcept {
+    return level_string_views.at(level_to_number(lvl));
+}
+
 struct thread_name_formatter : spdlog::formatter {
     ~thread_name_formatter() override = default;
 
@@ -31,8 +38,7 @@ struct thread_name_formatter : spdlog::formatter {
         dest.push_back(']');
         dest.push_back(' ');
         dest.push_back('<');
-        spdlog::details::fmt_helper::append_string_view(spdlog::to_string_view(msg.log_level),
-                                                        dest);
+        spdlog::details::fmt_helper::append_string_view(Log::to_string_view(msg.log_level), dest);
         dest.push_back('>');
         dest.push_back(' ');
         dest.push_back('(');

src/core/address_space.cpp

@@ -716,6 +716,12 @@ struct AddressSpace::Impl {
     void* Map(VAddr virtual_addr, PAddr phys_addr, u64 size, PosixPageProtection prot,
               int fd = -1) {
         m_free_regions.subtract({virtual_addr, virtual_addr + size});
+#ifdef __APPLE__
+        if ((prot & PROT_EXEC) != 0) {
+            ASSERT_MSG(fd == -1, "Requested execute permissions for file mapping");
+            phys_addr = -1;
+        }
+#endif
         const int handle = phys_addr != -1 ? (fd == -1 ? backing_fd : fd) : -1;
         const off_t host_offset = phys_addr != -1 ? phys_addr : 0;
         const int flag = phys_addr != -1 ? MAP_SHARED : (MAP_ANONYMOUS | MAP_PRIVATE);

src/core/libraries/kernel/process.cpp

@@ -17,8 +17,12 @@ s32 PS4_SYSV_ABI sceKernelIsInSandbox() {
 }
 
 s32 PS4_SYSV_ABI sceKernelIsNeoMode() {
-    return EmulatorSettings.IsNeo() &&
-           Common::ElfInfo::Instance().GetPSFAttributes().support_neo_mode;
+    static s32 IsNeoMode = -1;
+    if (IsNeoMode == -1) {
+        IsNeoMode = EmulatorSettings.IsNeo() &&
+                    Common::ElfInfo::Instance().GetPSFAttributes().support_neo_mode;
+    }
+    return IsNeoMode;
 }
 
 s32 PS4_SYSV_ABI sceKernelHasNeoMode() {

src/core/memory.cpp

@@ -951,7 +951,11 @@ s32 MemoryManager::UnmapMemoryImpl(VAddr virtual_addr, u64 size) {
 
 s32 MemoryManager::QueryProtection(VAddr addr, void** start, void** end, u32* prot) {
     std::shared_lock lk{mutex};
-    ASSERT_MSG(IsValidMapping(addr), "Attempted to access invalid address {:#x}", addr);
+    VAddr min_query_addr = impl.SystemManagedVirtualBase();
+    if (addr < min_query_addr) {
+        LOG_ERROR(Kernel_Vmm, "Address {:#x} is not mapped", addr);
+        return ORBIS_KERNEL_ERROR_EACCES;
+    }
 
     const auto it = FindVMA(addr);
     const auto& vma = it->second;

src/core/module.cpp

@@ -10,6 +10,7 @@
 #include "common/string_util.h"
 #include "core/aerolib/aerolib.h"
 #include "core/cpu_patches.h"
+#include "core/libraries/error_codes.h"
 #include "core/loader/dwarf.h"
 #include "core/memory.h"
 #include "core/module.h"
@@ -112,17 +113,20 @@ void Module::LoadModuleToMemory(u32& max_tls_index) {
 
     // Reserve memory area for module
     void** out_addr = reinterpret_cast<void**>(&base_virtual_addr);
-    memory->MapMemory(out_addr, ModuleLoadBase, aligned_base_size + TrampolineSize,
-                      MemoryProt::NoAccess, MemoryMapFlags::NoFlags, VMAType::Reserved, name);
+    s32 result =
+        memory->MapMemory(out_addr, ModuleLoadBase, aligned_base_size + TrampolineSize,
+                          MemoryProt::NoAccess, MemoryMapFlags::NoFlags, VMAType::Reserved, name);
+    ASSERT_MSG(result == ORBIS_OK, "Failed to reserve memory for module {}", name);
     LOG_INFO(Core_Linker, "Loading module {} to {}", name, fmt::ptr(*out_addr));
 
 #ifdef ARCH_X86_64
     // Initialize trampoline generator.
     VAddr trampoline_vaddr = base_virtual_addr + aligned_base_size;
     void* trampoline_addr = std::bit_cast<void*>(trampoline_vaddr);
-    memory->MapMemory(&trampoline_addr, trampoline_vaddr, TrampolineSize,
-                      MemoryProt::CpuReadWrite | MemoryProt::CpuExec, MemoryMapFlags::Fixed,
-                      VMAType::Code, name);
+    result = memory->MapMemory(&trampoline_addr, trampoline_vaddr, TrampolineSize,
+                               MemoryProt::CpuReadWrite | MemoryProt::CpuExec,
+                               MemoryMapFlags::Fixed, VMAType::Code, name);
+    ASSERT_MSG(result == ORBIS_OK, "Failed to map trampoline area for module {}", name);
     RegisterPatchModule(*out_addr, aligned_base_size, trampoline_addr, TrampolineSize);
 #endif
 
@@ -147,10 +151,13 @@ void Module::LoadModuleToMemory(u32& max_tls_index) {
             if ((phdr.p_flags & PF_EXEC) != 0) {
                 segment_prot |= MemoryProt::CpuExec;
             }
+
             // Map module segments
             const auto memory_type = IsSystemLib() ? VMAType::Code : VMAType::Flexible;
-            memory->MapMemory(&segment_addr, segment_vaddr, segment_size, segment_prot,
-                              MemoryMapFlags::Fixed, memory_type, name);
+            s32 result = memory->MapMemory(&segment_addr, segment_vaddr, segment_size, segment_prot,
+                                           MemoryMapFlags::Fixed, memory_type, name);
+            ASSERT_MSG(result == ORBIS_OK, "Failed to map segment at {:#x} for module {}",
+                       segment_vaddr, name);
             elf.LoadSegment(segment_vaddr, phdr.p_offset, phdr.p_filesz);
         }
         if (info.num_segments < 4) {

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -226,7 +226,12 @@ Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id lod
     Id texel;
     if (!texture.is_storage) {
         const Id image = ctx.OpLoad(texture.image_type, texture.id);
-        operands.Add(spv::ImageOperandsMask::Lod, lod);
+        if (texture.view_type != AmdGpu::ImageType::Color2DMsaa) {
+            if (Sirit::ValidId(ms)) {
+                LOG_ERROR(Render_Recompiler, "image is not MS but ms operand is provided");
+            }
+            operands.Add(spv::ImageOperandsMask::Lod, lod);
+        }
         texel = ctx.OpImageFetch(color_type, image, coords, operands.mask, operands.operands);
     } else {
         Id image_ptr = texture.id;

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -1058,7 +1058,7 @@ void PatchImageSampleArgs(IR::Block& block, IR::Inst& inst, Info& info,
 
     auto texel = [&] -> IR::Value {
         if (is_msaa) {
-            return ir.ImageRead(handle, coords, ir.Imm32(0U), ir.Imm32(0U), inst_info);
+            return ir.ImageRead(handle, coords, {}, ir.Imm32(0U), inst_info);
         }
         if (inst_info.is_gather) {
             if (inst_info.is_depth) {

src/video_core/buffer_cache/buffer_cache.cpp

@@ -441,7 +441,7 @@ std::pair<Buffer*, u32> BufferCache::ObtainBuffer(VAddr device_addr, u32 size,
     const bool is_texel_buffer = True(flags & ObtainBufferFlags::IsTexelBuffer);
     const bool skip_stream_buffer = True(flags & ObtainBufferFlags::IgnoreStreamBuffer);
     if (!is_written && !skip_stream_buffer && size <= CACHING_PAGESIZE &&
-        !IsRegionGpuModified(device_addr, size)) {
+        !IsRegionGpuModified(device_addr, size) && IsRegionCpuModified(device_addr, size)) {
         const u64 offset = stream_buffer.Copy(device_addr, size, instance.UniformMinAlignment());
         return {&stream_buffer, offset};
     }