fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-04-17 19:10:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

dzn: remove some needless casts

Browse source 
Acked-by: Boris Brezillon <boris.brezillon@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/16052>
This commit is contained in:
Erik Faye-Lund 2022-04-08 11:11:21 +02:00 • committed by Marge Bot
parent b8d41d5919
commit 92964d2bfd
8 changed files with 50 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -76,8 +76,7 @@ dzn_cmd_buffer_destroy(struct vk_command_buffer *cbuf)
if (cmdbuf->queries.ht) {
hash_table_foreach(cmdbuf->queries.ht, he) {
struct dzn_cmd_buffer_query_pool_state *qpstate =
(struct dzn_cmd_buffer_query_pool_state *)he->data;
struct dzn_cmd_buffer_query_pool_state *qpstate = he->data;
util_dynarray_fini(&qpstate->reset);
util_dynarray_fini(&qpstate->collect);
util_dynarray_fini(&qpstate->wait);
@ -129,7 +128,7 @@ dzn_cmd_buffer_create(const VkCommandBufferAllocateInfo *info,
D3D12_COMMAND_LIST_TYPE type =
pdev->queue_families[pool->queue_family_index].desc.Type;
struct dzn_cmd_buffer *cmdbuf = (struct dzn_cmd_buffer *)
struct dzn_cmd_buffer *cmdbuf =
vk_zalloc(&pool->alloc, sizeof(*cmdbuf), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!cmdbuf)
return vk_error(pool->base.device, VK_ERROR_OUT_OF_HOST_MEMORY);
@ -237,8 +236,7 @@ dzn_cmd_buffer_reset(struct dzn_cmd_buffer *cmdbuf)
vk_free(&cmdbuf->vk.pool->alloc, he->data);
_mesa_hash_table_clear(cmdbuf->dsvs.ht, NULL);
hash_table_foreach(cmdbuf->queries.ht, he) {
struct dzn_cmd_buffer_query_pool_state *qpstate =
(struct dzn_cmd_buffer_query_pool_state *)he->data;
struct dzn_cmd_buffer_query_pool_state *qpstate = he->data;
util_dynarray_fini(&qpstate->reset);
util_dynarray_fini(&qpstate->collect);
util_dynarray_fini(&qpstate->wait);
@ -345,7 +343,7 @@ dzn_cmd_buffer_gather_events(struct dzn_cmd_buffer *cmdbuf)
if (state != DZN_EVENT_STATE_EXTERNAL_WAIT) {
struct dzn_cmd_event_signal signal = { (struct dzn_event *)he->key, state == DZN_EVENT_STATE_SET };
struct dzn_cmd_event_signal *entry = (struct dzn_cmd_event_signal *)
struct dzn_cmd_event_signal *entry =
util_dynarray_grow(&cmdbuf->events.signal, struct dzn_cmd_event_signal, 1);
if (!entry) {
@ -454,7 +452,7 @@ static struct dzn_cmd_buffer_query_pool_state *
dzn_cmd_buffer_create_query_pool_state(struct dzn_cmd_buffer *cmdbuf)
{
struct dzn_device *device = container_of(cmdbuf->vk.base.device, struct dzn_device, vk);
struct dzn_cmd_buffer_query_pool_state *state = (struct dzn_cmd_buffer_query_pool_state *)
struct dzn_cmd_buffer_query_pool_state *state =
vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*state),
8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!state) {
@ -501,7 +499,7 @@ dzn_cmd_buffer_get_query_pool_state(struct dzn_cmd_buffer *cmdbuf,
return NULL;
}
} else {
state = (struct dzn_cmd_buffer_query_pool_state *)he->data;
state = he->data;
}
return state;
@ -599,7 +597,7 @@ dzn_cmd_buffer_collect_query_ops(struct dzn_cmd_buffer *cmdbuf,
BITSET_FOREACH_RANGE(start, end, bitset, nbits) {
struct dzn_cmd_buffer_query_range range = { qpool, start, end - start };
struct dzn_cmd_buffer_query_range *entry = (struct dzn_cmd_buffer_query_range *)
struct dzn_cmd_buffer_query_range *entry =
util_dynarray_grow(ops_array, struct dzn_cmd_buffer_query_range, 1);
if (!entry) {
@ -618,8 +616,7 @@ dzn_cmd_buffer_gather_queries(struct dzn_cmd_buffer *cmdbuf)
{
hash_table_foreach(cmdbuf->queries.ht, he) {
struct dzn_query_pool *qpool = (struct dzn_query_pool *)he->key;
struct dzn_cmd_buffer_query_pool_state *state =
(struct dzn_cmd_buffer_query_pool_state *)he->data;
struct dzn_cmd_buffer_query_pool_state *state = he->data;
VkResult result =
dzn_cmd_buffer_collect_queries(cmdbuf, qpool, state, 0, qpool->query_count);
if (result != VK_SUCCESS)
@ -785,16 +782,15 @@ dzn_cmd_buffer_get_dsv(struct dzn_cmd_buffer *cmdbuf,
uint32_t slot;
// TODO: error handling
dsve = (struct dzn_cmd_buffer_dsv_entry *)
vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*dsve), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
dsve = vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*dsve), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
dsve->key = key;
dzn_descriptor_heap_pool_alloc_slots(&cmdbuf->dsvs.pool, device, 1, &heap, &slot);
dsve->handle = dzn_descriptor_heap_get_cpu_handle(heap, slot);
ID3D12Device1_CreateDepthStencilView(device->dev, image->res, desc, dsve->handle);
_mesa_hash_table_insert(cmdbuf->dsvs.ht, &dsve->key, dsve);
} else {
dsve = (struct dzn_cmd_buffer_dsv_entry *)he->data;
dsve = he->data;
}
return dsve->handle;
@ -815,16 +811,15 @@ dzn_cmd_buffer_get_rtv(struct dzn_cmd_buffer *cmdbuf,
uint32_t slot;
// TODO: error handling
rtve = (struct dzn_cmd_buffer_rtv_entry *)
vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*rtve), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
rtve = vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*rtve), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
rtve->key = key;
dzn_descriptor_heap_pool_alloc_slots(&cmdbuf->rtvs.pool, device, 1, &heap, &slot);
rtve->handle = dzn_descriptor_heap_get_cpu_handle(heap, slot);
ID3D12Device1_CreateRenderTargetView(device->dev, image->res, desc, rtve->handle);
he = _mesa_hash_table_insert(cmdbuf->rtvs.ht, &rtve->key, rtve);
} else {
rtve = (struct dzn_cmd_buffer_rtv_entry *)he->data;
rtve = he->data;
}
return rtve->handle;
@ -870,7 +865,7 @@ dzn_cmd_buffer_alloc_internal_buf(struct dzn_cmd_buffer *cmdbuf,
return cmdbuf->error;
}
struct dzn_internal_resource *entry = (struct dzn_internal_resource *)
struct dzn_internal_resource *entry =
vk_alloc(&cmdbuf->vk.pool->alloc, sizeof(*entry), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!entry) {
@ -901,7 +896,7 @@ dzn_cmd_buffer_clear_rects_with_copy(struct dzn_cmd_buffer *cmdbuf,
assert(blksize <= sizeof(raw));
assert(!(sizeof(buf) % blksize));
util_format_write_4(pfmt, (void *)color, 0, (void *)raw, 0, 0, 0, 1, 1);
util_format_write_4(pfmt, color, 0, raw, 0, 0, 0, 1, 1);
uint32_t fill_step = D3D12_TEXTURE_DATA_PITCH_ALIGNMENT;
while (fill_step % blksize)
@ -930,7 +925,7 @@ dzn_cmd_buffer_clear_rects_with_copy(struct dzn_cmd_buffer *cmdbuf,
assert(!(res_size % fill_step));
uint8_t *cpu_ptr;
ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
ID3D12Resource_Map(src_res, 0, NULL, &cpu_ptr);
for (uint32_t i = 0; i < res_size; i += fill_step)
memcpy(&cpu_ptr[i], buf, fill_step);
@ -1052,7 +1047,7 @@ dzn_cmd_buffer_clear_ranges_with_copy(struct dzn_cmd_buffer *cmdbuf,
assert(blksize <= sizeof(raw));
assert(!(sizeof(buf) % blksize));
util_format_write_4(pfmt, (void *)color, 0, (void *)raw, 0, 0, 0, 1, 1);
util_format_write_4(pfmt, color, 0, raw, 0, 0, 0, 1, 1);
uint32_t fill_step = D3D12_TEXTURE_DATA_PITCH_ALIGNMENT;
while (fill_step % blksize)
@ -1086,7 +1081,7 @@ dzn_cmd_buffer_clear_ranges_with_copy(struct dzn_cmd_buffer *cmdbuf,
assert(!(res_size % fill_step));
uint8_t *cpu_ptr;
ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
ID3D12Resource_Map(src_res, 0, NULL, &cpu_ptr);
for (uint32_t i = 0; i < res_size; i += fill_step)
memcpy(&cpu_ptr[i], buf, fill_step);
@ -2860,7 +2855,7 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, indirect_draw->root_sig);
ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, indirect_draw->pipeline_state);
ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, 0, params_size / 4, (const void *)&params, 0);
ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, 0, params_size / 4, &params, 0);
ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(cmdbuf->cmdlist, 1, draw_buf_gpu);
ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(cmdbuf->cmdlist, 2, ID3D12Resource_GetGPUVirtualAddress(exec_buf));
if (triangle_fan_exec_buf)
@ -3357,7 +3352,7 @@ dzn_CmdFillBuffer(VkCommandBuffer commandBuffer,
return;
uint32_t *cpu_ptr;
ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
ID3D12Resource_Map(src_res, 0, NULL, &cpu_ptr);
for (uint32_t i = 0; i < size / 4; i++)
cpu_ptr[i] = data;
@ -3890,7 +3885,7 @@ dzn_CmdWaitEvents(VkCommandBuffer commandBuffer,
return;
}
struct dzn_event **entry = (struct dzn_event **)
struct dzn_event **entry =
util_dynarray_grow(&cmdbuf->events.wait, struct dzn_event *, 1);
if (!entry) {

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

@ -566,7 +566,7 @@ dzn_pipeline_layout_create(struct dzn_device *device,
}
}
D3D12_DESCRIPTOR_RANGE1 *ranges = (D3D12_DESCRIPTOR_RANGE1 *)
D3D12_DESCRIPTOR_RANGE1 *ranges =
vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*ranges) * range_count, 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
if (range_count && !ranges) {
@ -574,7 +574,7 @@ dzn_pipeline_layout_create(struct dzn_device *device,
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
}
D3D12_STATIC_SAMPLER_DESC *static_sampler_descs = (D3D12_STATIC_SAMPLER_DESC *)
D3D12_STATIC_SAMPLER_DESC *static_sampler_descs =
vk_alloc2(&device->vk.alloc, pAllocator,
sizeof(*static_sampler_descs) * static_sampler_count, 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
@ -1525,7 +1525,7 @@ dzn_descriptor_heap_pool_alloc_slots(struct dzn_descriptor_heap_pool *pool,
}
if (!new_heap) {
new_heap = (struct dzn_descriptor_heap_pool_entry *)
new_heap =
vk_zalloc(pool->alloc, sizeof(*new_heap), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!new_heap)

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

@ -151,7 +151,7 @@ dzn_instance_create(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkInstance *out)
{
struct dzn_instance *instance = (struct dzn_instance *)
struct dzn_instance *instance =
vk_zalloc2(vk_default_allocator(), pAllocator, sizeof(*instance), 8,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (!instance)
@ -214,7 +214,7 @@ dzn_physical_device_create(struct dzn_instance *instance,
IDXGIAdapter1 *adapter,
const DXGI_ADAPTER_DESC1 *adapter_desc)
{
struct dzn_physical_device *pdev = (struct dzn_physical_device *)
struct dzn_physical_device *pdev =
vk_zalloc(&instance->vk.alloc, sizeof(*pdev), 8,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
@ -2082,7 +2082,7 @@ dzn_device_memory_create(struct dzn_device *device,
struct dzn_physical_device *pdevice =
container_of(device->vk.physical, struct dzn_physical_device, vk);
struct dzn_device_memory *mem = (struct dzn_device_memory *)
struct dzn_device_memory *mem =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*mem), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!mem)
@ -2286,7 +2286,7 @@ dzn_buffer_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkBuffer *out)
{
struct dzn_buffer *buf = (struct dzn_buffer *)
struct dzn_buffer *buf =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*buf), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!buf)
@ -2603,7 +2603,7 @@ dzn_event_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkEvent *out)
{
struct dzn_event *event = (struct dzn_event *)
struct dzn_event *event =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*event), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!event)
@ -2730,7 +2730,7 @@ dzn_sampler_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkSampler *out)
{
struct dzn_sampler *sampler = (struct dzn_sampler *)
struct dzn_sampler *sampler =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*sampler), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!sampler)

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

@ -50,7 +50,7 @@ dzn_image_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkImage *out)
{
struct dzn_image *image = (struct dzn_image *)
struct dzn_image *image =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*image), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
struct dzn_physical_device *pdev =
@ -1123,7 +1123,7 @@ dzn_image_view_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkImageView *out)
{
struct dzn_image_view *iview = (struct dzn_image_view *)
struct dzn_image_view *iview =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*iview), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!iview)
@ -1174,7 +1174,7 @@ dzn_buffer_view_create(struct dzn_device *device,
{
VK_FROM_HANDLE(dzn_buffer, buf, pCreateInfo->buffer);
struct dzn_buffer_view *bview = (struct dzn_buffer_view *)
struct dzn_buffer_view *bview =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*bview), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!bview)

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

@ -426,12 +426,11 @@ dzn_meta_blits_get_fs(struct dzn_device *device,
dzn_meta_compile_shader(device, nir, &bc);
out = (D3D12_SHADER_BYTECODE *)
vk_alloc(&device->vk.alloc,
sizeof(D3D12_SHADER_BYTECODE) + bc.BytecodeLength, 8,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
out = vk_alloc(&device->vk.alloc,
sizeof(D3D12_SHADER_BYTECODE) + bc.BytecodeLength, 8,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (out) {
out->pShaderBytecode = (void *)(out + 1);
out->pShaderBytecode = out + 1;
memcpy((void *)out->pShaderBytecode, bc.pShaderBytecode, bc.BytecodeLength);
out->BytecodeLength = bc.BytecodeLength;
_mesa_hash_table_insert(meta->fs, &info->hash_key, out);
@ -439,7 +438,7 @@ dzn_meta_blits_get_fs(struct dzn_device *device,
free((void *)bc.pShaderBytecode);
ralloc_free(nir);
} else {
out = (D3D12_SHADER_BYTECODE *)he->data;
out = he->data;
}
mtx_unlock(&meta->shaders_lock);
@ -465,7 +464,7 @@ 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 = (struct dzn_meta_blit *)
struct dzn_meta_blit *blit =
vk_zalloc(&device->vk.alloc, sizeof(*blit), 8,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
@ -631,7 +630,7 @@ dzn_meta_blits_get_context(struct dzn_device *device,
mtx_lock(&device->blits.contexts_lock);
out = (struct dzn_meta_blit *)
out =
_mesa_hash_table_u64_search(device->blits.contexts, key->u64);
if (!out) {
out = dzn_meta_blit_create(device, key);
@ -660,7 +659,7 @@ dzn_meta_blits_finish(struct dzn_device *device)
if (meta->contexts) {
hash_table_foreach(meta->contexts->table, he)
dzn_meta_blit_destroy(device, (struct dzn_meta_blit *)he->data);
dzn_meta_blit_destroy(device, he->data);
_mesa_hash_table_u64_destroy(meta->contexts);
}

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

@ -68,10 +68,9 @@ dzn_pipeline_compile_shader(struct dzn_device *device,
uint32_t num_spec = 0;
if (spec_info && spec_info->mapEntryCount) {
spec = (struct dxil_spirv_specialization *)
vk_alloc2(&device->vk.alloc, alloc,
spec_info->mapEntryCount * sizeof(*spec), 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
spec = vk_alloc2(&device->vk.alloc, alloc,
spec_info->mapEntryCount * sizeof(*spec), 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
if (!spec)
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
@ -213,7 +212,7 @@ dzn_graphics_pipeline_translate_vi(struct dzn_graphics_pipeline *pipeline,
return VK_SUCCESS;
}
*input_elems = (D3D12_INPUT_ELEMENT_DESC *)
*input_elems =
vk_alloc2(&device->vk.alloc, alloc,
sizeof(**input_elems) * in_vi->vertexAttributeDescriptionCount, 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
@ -786,7 +785,7 @@ dzn_graphics_pipeline_create(struct dzn_device *device,
VkResult ret;
HRESULT hres = 0;
struct dzn_graphics_pipeline *pipeline = (struct dzn_graphics_pipeline *)
struct dzn_graphics_pipeline *pipeline =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pipeline)
@ -1075,7 +1074,7 @@ dzn_compute_pipeline_create(struct dzn_device *device,
{
VK_FROM_HANDLE(dzn_pipeline_layout, layout, pCreateInfo->layout);
struct dzn_compute_pipeline *pipeline = (struct dzn_compute_pipeline *)
struct dzn_compute_pipeline *pipeline =
vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pipeline)

2
src/microsoft/vulkan/dzn_pipeline_cache.c
View file

@ -44,7 +44,7 @@ dzn_pipeline_cache_create(struct dzn_device *device,
const VkAllocationCallbacks *pAllocator,
VkPipelineCache *out)
{
struct dzn_pipeline_cache *pcache = (struct dzn_pipeline_cache *)
struct dzn_pipeline_cache *pcache =
vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pcache), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pcache)

2
src/microsoft/vulkan/dzn_query.c
View file

@ -172,7 +172,7 @@ dzn_query_pool_create(struct dzn_device *device,
return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
}
hres = ID3D12Resource_Map(qpool->collect_buffer, 0, NULL, (void **)&qpool->collect_map);
hres = ID3D12Resource_Map(qpool->collect_buffer, 0, NULL, &qpool->collect_map);
if (FAILED(hres)) {
dzn_query_pool_destroy(qpool, alloc);
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);