Merge pull request #3535 from ReinUsesLisp/gcc-warnings

video_core: Silence misc warnings

externals/microprofile/microprofile.h

@@ -828,7 +828,7 @@ inline MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfi
     MicroProfileLogEntry Entry =  (nBegin<<62) | ((0x3fff&nToken)<<48) | (MP_LOG_TICK_MASK&nTick);
     int t = MicroProfileLogType(Entry);
     uint64_t nTimerIndex = MicroProfileLogTimerIndex(Entry);
-    MP_ASSERT(t == nBegin);
+    MP_ASSERT((uint64_t)t == nBegin);
     MP_ASSERT(nTimerIndex == (nToken&0x3fff));
     return Entry;
 
@@ -1556,10 +1556,10 @@ void MicroProfileFlip()
 
         pFramePut->nFrameStartCpu = MP_TICK();
         pFramePut->nFrameStartGpu = (uint32_t)MicroProfileGpuInsertTimeStamp();
-        if(pFrameNext->nFrameStartGpu != (uint64_t)-1)
+        if(pFrameNext->nFrameStartGpu != -1)
             pFrameNext->nFrameStartGpu = MicroProfileGpuGetTimeStamp((uint32_t)pFrameNext->nFrameStartGpu);
 
-        if(pFrameCurrent->nFrameStartGpu == (uint64_t)-1)
+        if(pFrameCurrent->nFrameStartGpu == -1)
             pFrameCurrent->nFrameStartGpu = pFrameNext->nFrameStartGpu + 1;
 
         uint64_t nFrameStartCpu = pFrameCurrent->nFrameStartCpu;

src/video_core/engines/kepler_compute.cpp

@@ -119,14 +119,6 @@ Texture::TICEntry KeplerCompute::GetTICEntry(u32 tic_index) const {
     Texture::TICEntry tic_entry;
     memory_manager.ReadBlockUnsafe(tic_address_gpu, &tic_entry, sizeof(Texture::TICEntry));
 
-    const auto r_type{tic_entry.r_type.Value()};
-    const auto g_type{tic_entry.g_type.Value()};
-    const auto b_type{tic_entry.b_type.Value()};
-    const auto a_type{tic_entry.a_type.Value()};
-
-    // TODO(Subv): Different data types for separate components are not supported
-    DEBUG_ASSERT(r_type == g_type && r_type == b_type && r_type == a_type);
-
     return tic_entry;
 }
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -93,10 +93,6 @@ void oglEnable(GLenum cap, bool state) {
     (state ? glEnable : glDisable)(cap);
 }
 
-void oglEnablei(GLenum cap, bool state, GLuint index) {
-    (state ? glEnablei : glDisablei)(cap, index);
-}
-
 } // Anonymous namespace
 
 RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
@@ -478,7 +474,6 @@ void RasterizerOpenGL::Clear() {
 void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
     auto& gpu = system.GPU().Maxwell3D();
-    const auto& regs = gpu.regs;
 
     query_cache.UpdateCounters();
 
@@ -529,7 +524,7 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     // Upload vertex and index data.
     SetupVertexBuffer();
     SetupVertexInstances();
-    GLintptr index_buffer_offset;
+    GLintptr index_buffer_offset = 0;
     if (is_indexed) {
         index_buffer_offset = SetupIndexBuffer();
     }
@@ -555,7 +550,7 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     ConfigureFramebuffers();
 
     // Signal the buffer cache that we are not going to upload more things.
-    const bool invalidate = buffer_cache.Unmap();
+    buffer_cache.Unmap();
 
     // Now that we are no longer uploading data, we can safely bind the buffers to OpenGL.
     vertex_array_pushbuffer.Bind();

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -393,10 +393,6 @@ std::string FlowStackTopName(MetaStackClass stack) {
     return fmt::format("{}_flow_stack_top", GetFlowStackPrefix(stack));
 }
 
-[[deprecated]] constexpr bool IsVertexShader(ShaderType stage) {
-    return stage == ShaderType::Vertex;
-}
-
 struct GenericVaryingDescription {
     std::string name;
     u8 first_element = 0;
@@ -529,8 +525,9 @@ private:
     }
 
     void DeclareVertex() {
-        if (!IsVertexShader(stage))
+        if (stage != ShaderType::Vertex) {
             return;
+        }
 
         DeclareVertexRedeclarations();
     }
@@ -602,14 +599,14 @@ private:
                 break;
             }
         }
-        if (!IsVertexShader(stage) || device.HasVertexViewportLayer()) {
+        if (stage != ShaderType::Vertex || device.HasVertexViewportLayer()) {
             if (ir.UsesLayer()) {
                 code.AddLine("int gl_Layer;");
             }
             if (ir.UsesViewportIndex()) {
                 code.AddLine("int gl_ViewportIndex;");
             }
-        } else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && IsVertexShader(stage) &&
+        } else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && stage == ShaderType::Vertex &&
                    !device.HasVertexViewportLayer()) {
             LOG_ERROR(
                 Render_OpenGL,
@@ -1147,7 +1144,7 @@ private:
             // TODO(Subv): Find out what the values are for the first two elements when inside a
             // vertex shader, and what's the value of the fourth element when inside a Tess Eval
             // shader.
-            ASSERT(IsVertexShader(stage));
+            ASSERT(stage == ShaderType::Vertex);
             switch (element) {
             case 2:
                 // Config pack's first value is instance_id.
@@ -1218,12 +1215,12 @@ private:
                 UNIMPLEMENTED();
                 return {};
             case 1:
-                if (IsVertexShader(stage) && !device.HasVertexViewportLayer()) {
+                if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
                     return {};
                 }
                 return {{"gl_Layer", Type::Int}};
             case 2:
-                if (IsVertexShader(stage) && !device.HasVertexViewportLayer()) {
+                if (stage == ShaderType::Vertex && !device.HasVertexViewportLayer()) {
                     return {};
                 }
                 return {{"gl_ViewportIndex", Type::Int}};
@@ -2532,7 +2529,7 @@ private:
     }
 
     u32 GetNumPhysicalInputAttributes() const {
-        return IsVertexShader(stage) ? GetNumPhysicalAttributes() : GetNumPhysicalVaryings();
+        return stage == ShaderType::Vertex ? GetNumPhysicalAttributes() : GetNumPhysicalVaryings();
     }
 
     u32 GetNumPhysicalAttributes() const {

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -257,6 +257,8 @@ vk::ShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
         return vk::ShaderStageFlagBits::eGeometry;
     case Tegra::Engines::ShaderType::Fragment:
         return vk::ShaderStageFlagBits::eFragment;
+    case Tegra::Engines::ShaderType::Compute:
+        return vk::ShaderStageFlagBits::eCompute;
     }
     UNIMPLEMENTED_MSG("Unimplemented shader stage={}", static_cast<u32>(stage));
     return {};

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -192,7 +192,6 @@ std::array<Shader, Maxwell::MaxShaderProgram> VKPipelineCache::GetShaders() {
 
     std::array<Shader, Maxwell::MaxShaderProgram> shaders;
     for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
-        const auto& shader_config = gpu.regs.shader_config[index];
         const auto program{static_cast<Maxwell::ShaderProgram>(index)};
 
         // Skip stages that are not enabled

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -548,8 +548,6 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 
     // Verify that the cached surface is the same size and format as the requested framebuffer
     const auto& params{surface->GetSurfaceParams()};
-    const auto& pixel_format{
-        VideoCore::Surface::PixelFormatFromGPUPixelFormat(config.pixel_format)};
     ASSERT_MSG(params.width == config.width, "Framebuffer width is different");
     ASSERT_MSG(params.height == config.height, "Framebuffer height is different");
 

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -100,7 +100,6 @@ void VKStagingBufferPool::ReleaseCache(bool host_visible) {
 }
 
 u64 VKStagingBufferPool::ReleaseLevel(StagingBuffersCache& cache, std::size_t log2) {
-    static constexpr u64 epochs_to_destroy = 180;
     static constexpr std::size_t deletions_per_tick = 16;
 
     auto& staging = cache[log2];
@@ -108,6 +107,7 @@ u64 VKStagingBufferPool::ReleaseLevel(StagingBuffersCache& cache, std::size_t lo
     const std::size_t old_size = entries.size();
 
     const auto is_deleteable = [this](const auto& entry) {
+        static constexpr u64 epochs_to_destroy = 180;
         return entry.last_epoch + epochs_to_destroy < epoch && !entry.watch.IsUsed();
     };
     const std::size_t begin_offset = staging.delete_index;

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -52,6 +52,9 @@ vk::ImageType SurfaceTargetToImage(SurfaceTarget target) {
         return vk::ImageType::e2D;
     case SurfaceTarget::Texture3D:
         return vk::ImageType::e3D;
+    case SurfaceTarget::TextureBuffer:
+        UNREACHABLE();
+        return {};
     }
     UNREACHABLE_MSG("Unknown texture target={}", static_cast<u32>(target));
     return {};
@@ -273,7 +276,6 @@ void CachedSurface::UploadImage(const std::vector<u8>& staging_buffer) {
 
     for (u32 level = 0; level < params.num_levels; ++level) {
         vk::BufferImageCopy copy = GetBufferImageCopy(level);
-        const auto& dld = device.GetDispatchLoader();
         if (image->GetAspectMask() ==
             (vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil)) {
             vk::BufferImageCopy depth = copy;
@@ -422,7 +424,6 @@ void VKTextureCache::ImageCopy(Surface& src_surface, Surface& dst_surface,
         dst_base_layer, num_layers, copy_params.dest_level, 1, vk::PipelineStageFlagBits::eTransfer,
         vk::AccessFlagBits::eTransferWrite, vk::ImageLayout::eTransferDstOptimal);
 
-    const auto& dld{device.GetDispatchLoader()};
     const vk::ImageSubresourceLayers src_subresource(
         src_surface->GetAspectMask(), copy_params.source_level, copy_params.source_z, num_layers);
     const vk::ImageSubresourceLayers dst_subresource(
@@ -458,7 +459,6 @@ void VKTextureCache::ImageBlit(View& src_view, View& dst_view,
                              dst_view->GetImageSubresourceLayers(), {dst_top_left, dst_bot_right});
     const bool is_linear = copy_config.filter == Tegra::Engines::Fermi2D::Filter::Linear;
 
-    const auto& dld{device.GetDispatchLoader()};
     scheduler.Record([src_image = src_view->GetImage(), dst_image = dst_view->GetImage(), blit,
                       is_linear](auto cmdbuf, auto& dld) {
         cmdbuf.blitImage(src_image, vk::ImageLayout::eTransferSrcOptimal, dst_image,