Core: Clang format and other small issues.

src/video_core/buffer_cache/buffer_cache.h

@@ -240,8 +240,8 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
         memory_tracker.MarkRegionAsGpuModified(*cpu_dest_address, amount);
     }
 
-    Tegra::Memory::DeviceGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::UnsafeReadWrite> tmp(
-        device_memory, *cpu_src_address, amount, &tmp_buffer);
+    Tegra::Memory::DeviceGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::UnsafeReadWrite>
+        tmp(device_memory, *cpu_src_address, amount, &tmp_buffer);
     tmp.SetAddressAndSize(*cpu_dest_address, amount);
     return true;
 }
@@ -1355,7 +1355,7 @@ typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(DAddr dev
     bool has_stream_leap = false;
     auto expand_begin = [&](DAddr add_value) {
         static constexpr DAddr min_page = CACHING_PAGESIZE + Core::Memory::YUZU_PAGESIZE;
-        if (add_value > begin - min_page ) {
+        if (add_value > begin - min_page) {
             begin = min_page;
             device_addr = Core::Memory::YUZU_PAGESIZE;
             return;
@@ -1365,7 +1365,7 @@ typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(DAddr dev
     };
     auto expand_end = [&](DAddr add_value) {
         static constexpr DAddr max_page = 1ULL << Tegra::MaxwellDeviceMemoryManager::AS_BITS;
-        if (add_value > max_page - end ) {
+        if (add_value > max_page - end) {
             end = max_page;
             return;
         }

src/video_core/buffer_cache/word_manager.h

@@ -472,8 +472,8 @@ private:
         u64 changed_bits = (add_to_tracker ? current_bits : ~current_bits) & new_bits;
         VAddr addr = cpu_addr + word_index * BYTES_PER_WORD;
         IteratePages(changed_bits, [&](size_t offset, size_t size) {
-            tracker->UpdatePagesCachedCount(addr + offset * BYTES_PER_PAGE,
-                                               size * BYTES_PER_PAGE, add_to_tracker ? 1 : -1);
+            tracker->UpdatePagesCachedCount(addr + offset * BYTES_PER_PAGE, size * BYTES_PER_PAGE,
+                                            add_to_tracker ? 1 : -1);
         });
     }
 

src/video_core/dma_pusher.cpp

@@ -86,14 +86,14 @@ bool DmaPusher::Step() {
         }
         const auto safe_process = [&] {
             Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader,
-                                         Tegra::Memory::GuestMemoryFlags::SafeRead>
+                                          Tegra::Memory::GuestMemoryFlags::SafeRead>
                 headers(memory_manager, dma_state.dma_get, command_list_header.size,
                         &command_headers);
             ProcessCommands(headers);
         };
         const auto unsafe_process = [&] {
             Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader,
-                                         Tegra::Memory::GuestMemoryFlags::UnsafeRead>
+                                          Tegra::Memory::GuestMemoryFlags::UnsafeRead>
                 headers(memory_manager, dma_state.dma_get, command_list_header.size,
                         &command_headers);
             ProcessCommands(headers);

src/video_core/engines/sw_blitter/blitter.cpp

@@ -8,10 +8,10 @@
 #include "common/scratch_buffer.h"
 #include "video_core/engines/sw_blitter/blitter.h"
 #include "video_core/engines/sw_blitter/converter.h"
+#include "video_core/guest_memory.h"
 #include "video_core/memory_manager.h"
 #include "video_core/surface.h"
 #include "video_core/textures/decoders.h"
-#include "video_core/guest_memory.h"
 
 namespace Tegra {
 class MemoryManager;

src/video_core/guest_memory.h

@@ -20,7 +20,8 @@ using GuestMemoryFlags = Core::Memory::GuestMemoryFlags;
 template <typename T, GuestMemoryFlags FLAGS>
 using DeviceGuestMemory = Core::Memory::GuestMemory<Tegra::MaxwellDeviceMemoryManager, T, FLAGS>;
 template <typename T, GuestMemoryFlags FLAGS>
-using DeviceGuestMemoryScoped = Core::Memory::GuestMemoryScoped<Tegra::MaxwellDeviceMemoryManager, T, FLAGS>;
+using DeviceGuestMemoryScoped =
+    Core::Memory::GuestMemoryScoped<Tegra::MaxwellDeviceMemoryManager, T, FLAGS>;
 template <typename T, GuestMemoryFlags FLAGS>
 using GpuGuestMemory = Core::Memory::GuestMemory<Tegra::MemoryManager, T, FLAGS>;
 template <typename T, GuestMemoryFlags FLAGS>

src/video_core/host1x/codecs/vp9.cpp

@@ -383,9 +383,8 @@ Vp9FrameContainer VP9::GetCurrentFrame(const Host1x::NvdecCommon::NvdecRegisters
         // gpu.SyncGuestHost(); epic, why?
         current_frame.info = GetVp9PictureInfo(state);
         current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        host1x.GMMU().ReadBlock(state.frame_bitstream_offset,
-                                         current_frame.bit_stream.data(),
-                                         current_frame.info.bitstream_size);
+        host1x.GMMU().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
+                                current_frame.info.bitstream_size);
     }
     if (!next_frame.bit_stream.empty()) {
         Vp9FrameContainer temp{

src/video_core/host1x/vic.cpp

@@ -167,7 +167,7 @@ void Vic::WriteRGBFrame(std::unique_ptr<FFmpeg::Frame> frame, const VicConfig& c
         // send pitch linear frame
         const size_t linear_size = width * height * 4;
         host1x.GMMU().WriteBlock(output_surface_luma_address, converted_frame_buf_addr,
-                                          linear_size);
+                                 linear_size);
     }
 }
 
@@ -193,8 +193,7 @@ void Vic::WriteYUVFrame(std::unique_ptr<FFmpeg::Frame> frame, const VicConfig& c
         const std::size_t dst = y * aligned_width;
         std::memcpy(luma_buffer.data() + dst, luma_src + src, frame_width);
     }
-    host1x.GMMU().WriteBlock(output_surface_luma_address, luma_buffer.data(),
-                                      luma_buffer.size());
+    host1x.GMMU().WriteBlock(output_surface_luma_address, luma_buffer.data(), luma_buffer.size());
 
     // Chroma
     const std::size_t half_height = frame_height / 2;
@@ -234,7 +233,7 @@ void Vic::WriteYUVFrame(std::unique_ptr<FFmpeg::Frame> frame, const VicConfig& c
         break;
     }
     host1x.GMMU().WriteBlock(output_surface_chroma_address, chroma_buffer.data(),
-                                      chroma_buffer.size());
+                             chroma_buffer.size());
 }
 
 } // namespace Host1x

src/video_core/memory_manager.h

@@ -38,8 +38,9 @@ class MemoryManager final {
 public:
     explicit MemoryManager(Core::System& system_, u64 address_space_bits_ = 40,
                            u64 big_page_bits_ = 16, u64 page_bits_ = 12);
-    explicit MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_, u64 address_space_bits_ = 40,
-                           u64 big_page_bits_ = 16, u64 page_bits_ = 12);
+    explicit MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_,
+                           u64 address_space_bits_ = 40, u64 big_page_bits_ = 16,
+                           u64 page_bits_ = 12);
     ~MemoryManager();
 
     size_t GetID() const {

src/video_core/query_cache/query_cache_base.h

@@ -15,9 +15,9 @@
 #include "common/common_types.h"
 #include "core/memory.h"
 #include "video_core/control/channel_state_cache.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/query_cache/query_base.h"
 #include "video_core/query_cache/types.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace VideoCore {
 class RasterizerInterface;
@@ -50,7 +50,8 @@ public:
     };
 
     explicit QueryCacheBase(Tegra::GPU& gpu, VideoCore::RasterizerInterface& rasterizer_,
-                            Tegra::MaxwellDeviceMemoryManager& device_memory_, RuntimeType& runtime_);
+                            Tegra::MaxwellDeviceMemoryManager& device_memory_,
+                            RuntimeType& runtime_);
 
     ~QueryCacheBase();
 

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -20,8 +20,7 @@ class BufferCacheRuntime;
 
 class Buffer : public VideoCommon::BufferBase {
 public:
-    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr,
-                    u64 size_bytes);
+    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr, u64 size_bytes);
     explicit Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams);
 
     void ImmediateUpload(size_t offset, std::span<const u8> data) noexcept;

src/video_core/renderer_opengl/gl_query_cache.cpp

@@ -35,7 +35,8 @@ constexpr GLenum GetTarget(VideoCore::QueryType type) {
 
 } // Anonymous namespace
 
-QueryCache::QueryCache(RasterizerOpenGL& rasterizer_, Tegra::MaxwellDeviceMemoryManager& device_memory_)
+QueryCache::QueryCache(RasterizerOpenGL& rasterizer_,
+                       Tegra::MaxwellDeviceMemoryManager& device_memory_)
     : QueryCacheLegacy(rasterizer_, device_memory_), gl_rasterizer{rasterizer_} {
     EnableCounters();
 }

src/video_core/renderer_opengl/gl_query_cache.h

@@ -8,10 +8,10 @@
 #include <vector>
 
 #include "common/common_types.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/query_cache.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Core {
 class System;
@@ -29,7 +29,8 @@ using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
 class QueryCache final
     : public VideoCommon::QueryCacheLegacy<QueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit QueryCache(RasterizerOpenGL& rasterizer_, Tegra::MaxwellDeviceMemoryManager& device_memory_);
+    explicit QueryCache(RasterizerOpenGL& rasterizer_,
+                        Tegra::MaxwellDeviceMemoryManager& device_memory_);
     ~QueryCache();
 
     OGLQuery AllocateQuery(VideoCore::QueryType type);

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -75,9 +75,9 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface,
                          protected VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo> {
 public:
     explicit RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
-                              Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device_,
-                              ScreenInfo& screen_info_, ProgramManager& program_manager_,
-                              StateTracker& state_tracker_);
+                              Tegra::MaxwellDeviceMemoryManager& device_memory_,
+                              const Device& device_, ScreenInfo& screen_info_,
+                              ProgramManager& program_manager_, StateTracker& state_tracker_);
     ~RasterizerOpenGL() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -97,8 +97,8 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                 render_window.GetFramebufferLayout().height),
       present_manager(instance, render_window, device, memory_allocator, scheduler, swapchain,
                       surface),
-      blit_screen(device_memory, render_window, device, memory_allocator, swapchain, present_manager,
-                  scheduler, screen_info),
+      blit_screen(device_memory, render_window, device, memory_allocator, swapchain,
+                  present_manager, scheduler, screen_info),
       rasterizer(render_window, gpu, device_memory, screen_info, device, memory_allocator,
                  state_tracker, scheduler) {
     if (Settings::values.renderer_force_max_clock.GetValue() && device.ShouldBoostClocks()) {

src/video_core/renderer_vulkan/renderer_vulkan.h

@@ -7,12 +7,12 @@
 #include <string>
 #include <variant>
 
-#include "video_core/renderer_vulkan/vk_rasterizer.h"
-
 #include "common/dynamic_library.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_vulkan/vk_blit_screen.h"
 #include "video_core/renderer_vulkan/vk_present_manager.h"
+#include "video_core/renderer_vulkan/vk_rasterizer.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
@@ -20,7 +20,6 @@
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Core {
 class TelemetrySession;

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -6,9 +6,9 @@
 #include <memory>
 
 #include "core/frontend/framebuffer_layout.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Core {
 class System;
@@ -53,8 +53,9 @@ struct ScreenInfo {
 
 class BlitScreen {
 public:
-    explicit BlitScreen(Tegra::MaxwellDeviceMemoryManager& device_memory, Core::Frontend::EmuWindow& render_window,
-                        const Device& device, MemoryAllocator& memory_manager, Swapchain& swapchain,
+    explicit BlitScreen(Tegra::MaxwellDeviceMemoryManager& device_memory,
+                        Core::Frontend::EmuWindow& render_window, const Device& device,
+                        MemoryAllocator& memory_manager, Swapchain& swapchain,
                         PresentManager& present_manager, Scheduler& scheduler,
                         const ScreenInfo& screen_info);
     ~BlitScreen();

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -298,8 +298,9 @@ bool GraphicsPipelineCacheKey::operator==(const GraphicsPipelineCacheKey& rhs) c
     return std::memcmp(&rhs, this, Size()) == 0;
 }
 
-PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device_,
-                             Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
+PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
+                             const Device& device_, Scheduler& scheduler_,
+                             DescriptorPool& descriptor_pool_,
                              GuestDescriptorQueue& guest_descriptor_queue_,
                              RenderPassCache& render_pass_cache_, BufferCache& buffer_cache_,
                              TextureCache& texture_cache_, VideoCore::ShaderNotify& shader_notify_)

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -20,13 +20,13 @@
 #include "shader_recompiler/object_pool.h"
 #include "shader_recompiler/profile.h"
 #include "video_core/engines/maxwell_3d.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/shader_cache.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Core {
 class System;
@@ -99,8 +99,8 @@ struct ShaderPools {
 
 class PipelineCache : public VideoCommon::ShaderCache {
 public:
-    explicit PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device, Scheduler& scheduler,
-                           DescriptorPool& descriptor_pool,
+    explicit PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device,
+                           Scheduler& scheduler, DescriptorPool& descriptor_pool,
                            GuestDescriptorQueue& guest_descriptor_queue,
                            RenderPassCache& render_pass_cache, BufferCache& buffer_cache,
                            TextureCache& texture_cache, VideoCore::ShaderNotify& shader_notify_);

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -14,10 +14,10 @@
 #include "common/bit_util.h"
 #include "common/common_types.h"
 #include "core/memory.h"
-#include "video_core/rasterizer_interface.h"
 #include "video_core/engines/draw_manager.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/query_cache/query_cache.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/renderer_vulkan/vk_query_cache.h"
@@ -1156,9 +1156,10 @@ private:
 
 struct QueryCacheRuntimeImpl {
     QueryCacheRuntimeImpl(QueryCacheRuntime& runtime, VideoCore::RasterizerInterface* rasterizer_,
-                          Tegra::MaxwellDeviceMemoryManager& device_memory_, Vulkan::BufferCache& buffer_cache_,
-                          const Device& device_, const MemoryAllocator& memory_allocator_,
-                          Scheduler& scheduler_, StagingBufferPool& staging_pool_,
+                          Tegra::MaxwellDeviceMemoryManager& device_memory_,
+                          Vulkan::BufferCache& buffer_cache_, const Device& device_,
+                          const MemoryAllocator& memory_allocator_, Scheduler& scheduler_,
+                          StagingBufferPool& staging_pool_,
                           ComputePassDescriptorQueue& compute_pass_descriptor_queue,
                           DescriptorPool& descriptor_pool)
         : rasterizer{rasterizer_}, device_memory{device_memory_},

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -38,7 +38,6 @@
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
-
 namespace Vulkan {
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -7,13 +7,13 @@
 
 #include <boost/container/static_vector.hpp>
 
-#include "video_core/renderer_vulkan/vk_buffer_cache.h"
-
 #include "common/common_types.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/engines/maxwell_dma.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_vulkan/blit_image.h"
+#include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
@@ -24,7 +24,6 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Core {
 class System;

src/video_core/shader_cache.cpp

@@ -35,7 +35,8 @@ void ShaderCache::SyncGuestHost() {
     RemovePendingShaders();
 }
 
-ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_) : device_memory{device_memory_} {}
+ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_)
+    : device_memory{device_memory_} {}
 
 bool ShaderCache::RefreshStages(std::array<u64, 6>& unique_hashes) {
     auto& dirty{maxwell3d->dirty.flags};

src/video_core/shader_cache.h

@@ -14,9 +14,9 @@
 #include "common/common_types.h"
 #include "common/polyfill_ranges.h"
 #include "video_core/control/channel_state_cache.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/shader_environment.h"
-#include "video_core/host1x/gpu_device_memory_manager.h"
 
 namespace Tegra {
 class MemoryManager;