fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-04 22:49:13 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

dzn: Fix unused var warnings

Browse source 
Reviewed-by: Jesse Natalie <jenatali@microsoft.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17250>
This commit is contained in:
Boris Brezillon 2022-06-28 14:48:00 +02:00
parent bb8ca4bafe
commit 97dbebb558
8 changed files with 7 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
src/microsoft/vulkan/dzn_cmd_buffer.c
View file

@ -202,7 +202,6 @@ dzn_cmd_buffer_queue_image_range_layout_transition(struct dzn_cmd_buffer *cmdbuf
uint32_t flags)
{
uint32_t first_barrier = 0, barrier_count = 0;
bool is_undefined = old_layout == VK_IMAGE_LAYOUT_UNDEFINED;
VkResult ret = VK_SUCCESS;
if (old_layout == VK_IMAGE_LAYOUT_UNDEFINED)
@ -258,7 +257,6 @@ dzn_cmd_buffer_destroy(struct vk_command_buffer *cbuf)
return;
struct dzn_cmd_buffer *cmdbuf = container_of(cbuf, struct dzn_cmd_buffer, vk);
struct dzn_device *device = container_of(cbuf->base.device, struct dzn_device, vk);
if (cmdbuf->cmdlist)
ID3D12GraphicsCommandList1_Release(cmdbuf->cmdlist);
@ -512,7 +510,6 @@ dzn_AllocateCommandBuffers(VkDevice device,
const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers)
{
VK_FROM_HANDLE(vk_command_pool, pool, pAllocateInfo->commandPool);
VK_FROM_HANDLE(dzn_device, dev, device);
VkResult result = VK_SUCCESS;
uint32_t i;
@ -628,8 +625,6 @@ dzn_cmd_buffer_dynbitset_test(struct util_dynarray *array, uint32_t bit)
static VkResult
dzn_cmd_buffer_dynbitset_set(struct dzn_cmd_buffer *cmdbuf, struct util_dynarray *array, uint32_t bit)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VkResult result = dzn_cmd_buffer_dynbitset_reserve(cmdbuf, array, bit);
if (result != VK_SUCCESS)
return result;
@ -641,8 +636,6 @@ dzn_cmd_buffer_dynbitset_set(struct dzn_cmd_buffer *cmdbuf, struct util_dynarray
static void
dzn_cmd_buffer_dynbitset_clear(struct dzn_cmd_buffer *cmdbuf, struct util_dynarray *array, uint32_t bit)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
if (bit >= util_dynarray_num_elements(array, BITSET_WORD) * BITSET_WORDBITS)
return;
@ -654,8 +647,6 @@ dzn_cmd_buffer_dynbitset_set_range(struct dzn_cmd_buffer *cmdbuf,
struct util_dynarray *array,
uint32_t bit, uint32_t count)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VkResult result = dzn_cmd_buffer_dynbitset_reserve(cmdbuf, array, bit + count - 1);
if (result != VK_SUCCESS)
return result;
@ -669,7 +660,6 @@ dzn_cmd_buffer_dynbitset_clear_range(struct dzn_cmd_buffer *cmdbuf,
struct util_dynarray *array,
uint32_t bit, uint32_t count)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
uint32_t nbits = util_dynarray_num_elements(array, BITSET_WORD) * BITSET_WORDBITS;
if (!nbits)
@ -1180,9 +1170,6 @@ dzn_cmd_buffer_clear_rects_with_copy(struct dzn_cmd_buffer *cmdbuf,
},
};
D3D12_RESOURCE_STATES dst_state =
dzn_image_layout_to_state(image, layout, VK_IMAGE_ASPECT_COLOR_BIT);
dzn_cmd_buffer_queue_transition_barriers(cmdbuf, src_res, 0, 1,
D3D12_RESOURCE_STATE_GENERIC_READ,
D3D12_RESOURCE_STATE_COPY_SOURCE,
@ -1318,9 +1305,6 @@ dzn_cmd_buffer_clear_ranges_with_copy(struct dzn_cmd_buffer *cmdbuf,
},
};
D3D12_RESOURCE_STATES dst_state =
dzn_image_layout_to_state(image, layout, VK_IMAGE_ASPECT_COLOR_BIT);
dzn_cmd_buffer_queue_transition_barriers(cmdbuf, src_res, 0, 1,
D3D12_RESOURCE_STATE_GENERIC_READ,
D3D12_RESOURCE_STATE_COPY_SOURCE,
@ -1523,7 +1507,6 @@ dzn_cmd_buffer_clear_color(struct dzn_cmd_buffer *cmdbuf,
for (uint32_t r = 0; r < range_count; r++) {
const VkImageSubresourceRange *range = &ranges[r];
uint32_t layer_count = dzn_get_layer_count(image, range);
uint32_t level_count = dzn_get_level_count(image, range);
dzn_cmd_buffer_queue_image_range_layout_transition(cmdbuf, image, range,
@ -1562,7 +1545,6 @@ dzn_cmd_buffer_clear_zs(struct dzn_cmd_buffer *cmdbuf,
for (uint32_t r = 0; r < range_count; r++) {
const VkImageSubresourceRange *range = &ranges[r];
uint32_t layer_count = dzn_get_layer_count(image, range);
uint32_t level_count = dzn_get_level_count(image, range);
D3D12_CLEAR_FLAGS flags = (D3D12_CLEAR_FLAGS)0;
@ -1601,11 +1583,9 @@ dzn_cmd_buffer_copy_buf2img_region(struct dzn_cmd_buffer *cmdbuf,
VkImageAspectFlagBits aspect,
uint32_t l)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VK_FROM_HANDLE(dzn_buffer, src_buffer, info->srcBuffer);
VK_FROM_HANDLE(dzn_image, dst_image, info->dstImage);
ID3D12Device2 *dev = device->dev;
ID3D12GraphicsCommandList1 *cmdlist = cmdbuf->cmdlist;
VkBufferImageCopy2 region = info->pRegions[r];
@ -1682,11 +1662,9 @@ dzn_cmd_buffer_copy_img2buf_region(struct dzn_cmd_buffer *cmdbuf,
VkImageAspectFlagBits aspect,
uint32_t l)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VK_FROM_HANDLE(dzn_image, src_image, info->srcImage);
VK_FROM_HANDLE(dzn_buffer, dst_buffer, info->dstBuffer);
ID3D12Device2 *dev = device->dev;
ID3D12GraphicsCommandList1 *cmdlist = cmdbuf->cmdlist;
VkBufferImageCopy2 region = info->pRegions[r];
@ -2136,7 +2114,6 @@ dzn_cmd_buffer_blit_region(struct dzn_cmd_buffer *cmdbuf,
uint32_t *heap_slot,
uint32_t r)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VK_FROM_HANDLE(dzn_image, src, info->srcImage);
VK_FROM_HANDLE(dzn_image, dst, info->dstImage);
@ -2212,11 +2189,9 @@ dzn_cmd_buffer_resolve_region(struct dzn_cmd_buffer *cmdbuf,
uint32_t *heap_slot,
uint32_t r)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VK_FROM_HANDLE(dzn_image, src, info->srcImage);
VK_FROM_HANDLE(dzn_image, dst, info->dstImage);
ID3D12Device2 *dev = device->dev;
const VkImageResolve2 *region = &info->pRegions[r];
dzn_foreach_aspect(aspect, region->srcSubresource.aspectMask) {
@ -2330,7 +2305,6 @@ dzn_cmd_buffer_update_heaps(struct dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
struct dzn_descriptor_heap_pool *pool =
type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV ?
&cmdbuf->cbv_srv_uav_pool : &cmdbuf->sampler_pool;
uint32_t dst_offset = 0;
struct dzn_descriptor_heap *dst_heap = NULL;
uint32_t dst_heap_offset = 0;
@ -2458,7 +2432,6 @@ dzn_cmd_buffer_update_scissors(struct dzn_cmd_buffer *cmdbuf)
}
D3D12_RECT scissors[MAX_SCISSOR];
uint32_t scissor_count = pipeline->scissor.count;
memcpy(scissors, cmdbuf->state.scissors, sizeof(D3D12_RECT) * pipeline->scissor.count);
for (uint32_t i = 0; i < pipeline->scissor.count; i++) {
@ -2474,8 +2447,6 @@ dzn_cmd_buffer_update_scissors(struct dzn_cmd_buffer *cmdbuf)
static void
dzn_cmd_buffer_update_vbviews(struct dzn_cmd_buffer *cmdbuf)
{
const struct dzn_graphics_pipeline *pipeline =
(const struct dzn_graphics_pipeline *)cmdbuf->state.pipeline;
unsigned start, end;
BITSET_FOREACH_RANGE(start, end, cmdbuf->state.vb.dirty, MAX_VBS)
@ -2554,7 +2525,6 @@ dzn_cmd_buffer_update_depth_bounds(struct dzn_cmd_buffer *cmdbuf)
static VkResult
dzn_cmd_buffer_triangle_fan_create_index(struct dzn_cmd_buffer *cmdbuf, uint32_t *vertex_count)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
uint8_t index_size = *vertex_count <= 0xffff ? 2 : 4;
uint32_t triangle_count = MAX2(*vertex_count, 2) - 2;
@ -2637,9 +2607,6 @@ dzn_cmd_buffer_triangle_fan_rewrite_index(struct dzn_cmd_buffer *cmdbuf,
const struct dzn_meta_triangle_fan_rewrite_index *rewrite_index =
&device->triangle_fan[index_type];
const struct dzn_pipeline *compute_pipeline =
cmdbuf->state.bindpoint[VK_PIPELINE_BIND_POINT_COMPUTE].pipeline;
struct dzn_triangle_fan_rewrite_index_params params = {
.first_index = *first_index,
};
@ -2740,7 +2707,6 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
struct dzn_graphics_pipeline *pipeline = (struct dzn_graphics_pipeline *)
cmdbuf->state.bindpoint[VK_PIPELINE_BIND_POINT_GRAPHICS].pipeline;
bool triangle_fan = pipeline->ia.triangle_fan;
uint32_t min_draw_buf_stride =
indexed ?
sizeof(struct dzn_indirect_indexed_draw_params) :
@ -2752,7 +2718,6 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
assert(draw_buf_stride >= min_draw_buf_stride);
assert((draw_buf_stride & 3) == 0);
uint32_t sysvals_stride = ALIGN_POT(sizeof(cmdbuf->state.sysvals.gfx), 256);
uint32_t triangle_fan_index_buf_stride =
dzn_cmd_buffer_triangle_fan_get_max_index_buf_size(cmdbuf, indexed) *
sizeof(uint32_t);
@ -2848,9 +2813,6 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
}
struct dzn_meta_indirect_draw *indirect_draw = &device->indirect_draws[draw_type];
const struct dzn_pipeline *compute_pipeline =
cmdbuf->state.bindpoint[VK_PIPELINE_BIND_POINT_COMPUTE].pipeline;
uint32_t root_param_idx = 0;
ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, indirect_draw->root_sig);
@ -3213,7 +3175,6 @@ dzn_CmdBlitImage2(VkCommandBuffer commandBuffer,
ID3D12GraphicsCommandList1_IASetPrimitiveTopology(cmdbuf->cmdlist, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
uint32_t heap_offset = 0;
for (uint32_t r = 0; r < info->regionCount; r++)
dzn_cmd_buffer_blit_region(cmdbuf, info, heap, &heap_slot, r);
@ -3400,7 +3361,6 @@ dzn_CmdClearAttachments(VkCommandBuffer commandBuffer,
VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
struct dzn_image_view *view = NULL;
uint32_t idx = VK_ATTACHMENT_UNUSED;
if (pAttachments[i].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
assert(pAttachments[i].colorAttachment < cmdbuf->state.render.attachments.color_count);
view = cmdbuf->state.render.attachments.colors[pAttachments[i].colorAttachment].iview;
@ -4216,7 +4176,6 @@ dzn_CmdBeginQuery(VkCommandBuffer commandBuffer,
VkQueryControlFlags flags)
{
VK_FROM_HANDLE(dzn_cmd_buffer, cmdbuf, commandBuffer);
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
VK_FROM_HANDLE(dzn_query_pool, qpool, queryPool);
struct dzn_cmd_buffer_query_pool_state *state =

3
src/microsoft/vulkan/dzn_descriptor_set.c
View file

@ -1695,7 +1695,6 @@ dzn_FreeDescriptorSets(VkDevice dev,
const VkDescriptorSet *pDescriptorSets)
{
VK_FROM_HANDLE(dzn_descriptor_pool, pool, descriptorPool);
VK_FROM_HANDLE(dzn_device, device, dev);
for (uint32_t s = 0; s < count; s++) {
VK_FROM_HANDLE(dzn_descriptor_set, set, pDescriptorSets[s]);
@ -1944,8 +1943,6 @@ dzn_UpdateDescriptorSets(VkDevice _device,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies)
{
VK_FROM_HANDLE(dzn_device, dev, _device);
for (unsigned i = 0; i < descriptorWriteCount; i++)
dzn_descriptor_set_write(&pDescriptorWrites[i]);

7
src/microsoft/vulkan/dzn_device.c
View file

@ -651,8 +651,6 @@ dzn_physical_device_get_format_properties(struct dzn_physical_device *pdev,
return;
}
ID3D12Device2 *dev = dzn_physical_device_get_d3d12_dev(pdev);
*base_props = (VkFormatProperties) {
.linearTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
.optimalTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
@ -2122,8 +2120,6 @@ dzn_CreateDevice(VkPhysicalDevice physicalDevice,
VkDevice *pDevice)
{
VK_FROM_HANDLE(dzn_physical_device, physical_device, physicalDevice);
struct dzn_instance *instance =
container_of(physical_device->vk.instance, struct dzn_instance, vk);
VkResult result;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
@ -2373,7 +2369,6 @@ VKAPI_ATTR void VKAPI_CALL
dzn_UnmapMemory(VkDevice _device,
VkDeviceMemory _memory)
{
VK_FROM_HANDLE(dzn_device, device, _device);
VK_FROM_HANDLE(dzn_device_memory, mem, _memory);
if (mem == NULL)
@ -2475,8 +2470,6 @@ dzn_buffer_get_copy_loc(const struct dzn_buffer *buf,
{
const uint32_t buffer_row_length =
region->bufferRowLength ? region->bufferRowLength : region->imageExtent.width;
const uint32_t buffer_image_height =
region->bufferImageHeight ? region->bufferImageHeight : region->imageExtent.height;
VkFormat plane_format = dzn_image_get_plane_format(format, aspect);

11
src/microsoft/vulkan/dzn_image.c
View file

@ -77,10 +77,6 @@ dzn_image_create(struct dzn_device *device,
if (!image)
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
const VkExternalMemoryImageCreateInfo *create_info =
(const VkExternalMemoryImageCreateInfo *)
vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
#if 0
VkExternalMemoryHandleTypeFlags supported =
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
@ -357,12 +353,8 @@ dzn_image_get_copy_loc(const struct dzn_image *image,
};
assert((subres->aspectMask & aspect) != 0);
VkFormat format = dzn_image_get_plane_format(image->vk.format, aspect);
if (image->desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) {
VkImageUsageFlags usage =
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
assert((subres->baseArrayLayer + layer) == 0);
assert(subres->mipLevel == 0);
loc.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
@ -1093,10 +1085,7 @@ dzn_image_view_init(struct dzn_device *device,
VK_FROM_HANDLE(dzn_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
uint32_t level_count = dzn_get_level_count(image, range);
uint32_t layer_count = dzn_get_layer_count(image, range);
uint32_t plane_slice =
pCreateInfo->subresourceRange.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT ? 1 : 0;
vk_image_view_init(&device->vk, &iview->vk, false, pCreateInfo);

5
src/microsoft/vulkan/dzn_meta.c
View file

@ -424,7 +424,6 @@ static const D3D12_SHADER_BYTECODE *
dzn_meta_blits_get_vs(struct dzn_device *device)
{
struct dzn_meta_blits *meta = &device->blits;
D3D12_SHADER_BYTECODE *out;
mtx_lock(&meta->shaders_lock);
@ -450,12 +449,9 @@ dzn_meta_blits_get_vs(struct dzn_device *device)
if (meta->vs.pShaderBytecode) {
meta->vs.BytecodeLength = bc.BytecodeLength;
memcpy((void *)meta->vs.pShaderBytecode, bc.pShaderBytecode, bc.BytecodeLength);
out = &meta->vs;
}
free((void *)bc.pShaderBytecode);
ralloc_free(nir);
} else {
out = &meta->vs;
}
mtx_unlock(&meta->shaders_lock);
@ -530,7 +526,6 @@ dzn_meta_blit_destroy(struct dzn_device *device, struct dzn_meta_blit *blit)
static struct dzn_meta_blit *
dzn_meta_blit_create(struct dzn_device *device, const struct dzn_meta_blit_key *key)
{
struct dzn_meta_blits *blits = &device->blits;
struct dzn_meta_blit *blit =
vk_zalloc(&device->vk.alloc, sizeof(*blit), 8,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);

7
src/microsoft/vulkan/dzn_nir.c
View file

@ -125,13 +125,6 @@ dzn_nir_indirect_draw_shader(enum dzn_indirect_draw_type type)
type_str[type]);
b.shader->info.internal = true;
struct glsl_struct_field field = {
.type = glsl_uint_type(),
.name = "dummy_int",
};
const struct glsl_type *dummy_type =
glsl_struct_type(&field, 1, "dummy_type", false);
nir_ssa_def *params_desc =
dzn_nir_create_bo_desc(&b, nir_var_mem_ubo, 0, 0, "params", 0);
nir_ssa_def *draw_buf_desc =

9
src/microsoft/vulkan/dzn_pipeline.c
View file

@ -208,9 +208,6 @@ dzn_pipeline_get_nir_shader(struct dzn_device *device,
return VK_SUCCESS;
}
struct dzn_instance *instance =
container_of(device->vk.physical->instance, struct dzn_instance, vk);
const VkSpecializationInfo *spec_info = stage_info->pSpecializationInfo;
VK_FROM_HANDLE(vk_shader_module, module, stage_info->module);
struct spirv_to_nir_options spirv_opts = {
.caps = {
@ -948,8 +945,6 @@ dzn_graphics_pipeline_translate_vi(struct dzn_graphics_pipeline *pipeline,
D3D12_INPUT_ELEMENT_DESC *inputs,
enum pipe_format *vi_conversions)
{
struct dzn_device *device =
container_of(pipeline->base.base.device, struct dzn_device, vk);
const VkPipelineVertexInputStateCreateInfo *in_vi =
in->pVertexInputState;
const VkPipelineVertexInputDivisorStateCreateInfoEXT *divisors =
@ -1631,10 +1626,6 @@ dzn_graphics_pipeline_create(struct dzn_device *device,
D3D12_INPUT_ELEMENT_DESC attribs[MAX_VERTEX_GENERIC_ATTRIBS] = { 0 };
enum pipe_format vi_conversions[MAX_VERTEX_GENERIC_ATTRIBS] = { 0 };
const VkPipelineViewportStateCreateInfo *vp_info =
pCreateInfo->pRasterizationState->rasterizerDiscardEnable ?
NULL : pCreateInfo->pViewportState;
ret = dzn_graphics_pipeline_translate_vi(pipeline, pCreateInfo,
attribs, vi_conversions);
if (ret != VK_SUCCESS)

7
src/microsoft/vulkan/meson.build
View file

@ -61,6 +61,13 @@ if with_platform_windows
dzn_flags += '-DVK_USE_PLATFORM_WIN32_KHR'
endif
if cc.get_argument_syntax() != 'msvc'
dzn_flags += [
'-Werror=unused-variable',
'-Werror=unused-but-set-variable',
]
endif
libvulkan_dzn = shared_library(
'vulkan_dzn',
[libdzn_files, dzn_entrypoints, sha1_h],