wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-01-28 13:05:02 -08:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader/dxbc: Use return type to return result from read_u32 and read_float.

Browse Source 
Avoid implicit casts from enum pointers.
This commit is contained in:
Jacek Caban 2023-11-17 12:52:19 +01:00 committed by Alexandre Julliard
parent b1123ed35f
commit 078cf6a240
Notes: Alexandre Julliard 2023-11-20 22:33:17 +01:00 
Approved-by: Giovanni Mascellani (@giomasce)
Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/483
1 changed files with 83 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
libs/vkd3d-shader/dxbc.c
View File

@ -94,16 +94,24 @@ static bool require_space(size_t offset, size_t count, size_t size, size_t data_
return !count || (data_size - offset) / count >= size; return !count || (data_size - offset) / count >= size;
} }
static void read_dword(const char **ptr, uint32_t *d) static uint32_t read_u32(const char **ptr)
{ {
memcpy(d, *ptr, sizeof(*d)); unsigned int ret;
*ptr += sizeof(*d); memcpy(&ret, *ptr, sizeof(ret));
*ptr += sizeof(ret);
return ret;
} }
static void read_float(const char **ptr, float *f) static float read_float(const char **ptr)
{ {
union
{
uint32_t i;
float f;
} u;
STATIC_ASSERT(sizeof(float) == sizeof(uint32_t)); STATIC_ASSERT(sizeof(float) == sizeof(uint32_t));
read_dword(ptr, (uint32_t *)f); u.i = read_u32(ptr);
return u.f;
} }
static void skip_dword_unknown(const char **ptr, unsigned int count) static void skip_dword_unknown(const char **ptr, unsigned int count)
@ -117,7 +125,7 @@ static void skip_dword_unknown(const char **ptr, unsigned int count)
WARN("Skipping %u unknown DWORDs:\n", count); WARN("Skipping %u unknown DWORDs:\n", count);
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(ptr, &d); d = read_u32(ptr);
WARN("\t0x%08x\n", d); WARN("\t0x%08x\n", d);
} }
} }
@ -164,7 +172,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &tag); tag = read_u32(&ptr);
TRACE("tag: %#x.\n", tag); TRACE("tag: %#x.\n", tag);
if (tag != TAG_DXBC) if (tag != TAG_DXBC)
@ -174,10 +182,10 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &checksum[0]); checksum[0] = read_u32(&ptr);
read_dword(&ptr, &checksum[1]); checksum[1] = read_u32(&ptr);
read_dword(&ptr, &checksum[2]); checksum[2] = read_u32(&ptr);
read_dword(&ptr, &checksum[3]); checksum[3] = read_u32(&ptr);
vkd3d_compute_dxbc_checksum(data, data_size, calculated_checksum); vkd3d_compute_dxbc_checksum(data, data_size, calculated_checksum);
if (memcmp(checksum, calculated_checksum, sizeof(checksum))) if (memcmp(checksum, calculated_checksum, sizeof(checksum)))
{ {
@ -191,7 +199,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &version); version = read_u32(&ptr);
TRACE("version: %#x.\n", version); TRACE("version: %#x.\n", version);
if (version != 0x00000001) if (version != 0x00000001)
{ {
@ -201,10 +209,10 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &total_size); total_size = read_u32(&ptr);
TRACE("total size: %#x\n", total_size); TRACE("total size: %#x\n", total_size);
read_dword(&ptr, &chunk_count); chunk_count = read_u32(&ptr);
TRACE("chunk count: %#x\n", chunk_count); TRACE("chunk count: %#x\n", chunk_count);
if (!(sections = vkd3d_calloc(chunk_count, sizeof(*sections)))) if (!(sections = vkd3d_calloc(chunk_count, sizeof(*sections))))
@ -219,7 +227,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
const char *chunk_ptr; const char *chunk_ptr;
uint32_t chunk_offset; uint32_t chunk_offset;
read_dword(&ptr, &chunk_offset); chunk_offset = read_u32(&ptr);
TRACE("chunk %u at offset %#x\n", i, chunk_offset); TRACE("chunk %u at offset %#x\n", i, chunk_offset);
if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size)) if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size))
@ -233,8 +241,8 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_
chunk_ptr = data + chunk_offset; chunk_ptr = data + chunk_offset;
read_dword(&chunk_ptr, &chunk_tag); chunk_tag = read_u32(&chunk_ptr);
read_dword(&chunk_ptr, &chunk_size); chunk_size = read_u32(&chunk_ptr);
if (!require_space(chunk_ptr - data, 1, chunk_size, data_size)) if (!require_space(chunk_ptr - data, 1, chunk_size, data_size))
{ {
@ -359,10 +367,10 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &count); count = read_u32(&ptr);
TRACE("%u elements.\n", count); TRACE("%u elements.\n", count);
read_dword(&ptr, &header_size); header_size = read_u32(&ptr);
i = header_size / sizeof(uint32_t); i = header_size / sizeof(uint32_t);
if (align(header_size, sizeof(uint32_t)) != header_size || i < 2 if (align(header_size, sizeof(uint32_t)) != header_size || i < 2
|| !require_space(2, i - 2, sizeof(uint32_t), section->data.size)) || !require_space(2, i - 2, sizeof(uint32_t), section->data.size))
@ -396,24 +404,24 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
e[i].sort_index = i; e[i].sort_index = i;
if (has_stream_index) if (has_stream_index)
read_dword(&ptr, &e[i].stream_index); e[i].stream_index = read_u32(&ptr);
else else
e[i].stream_index = 0; e[i].stream_index = 0;
read_dword(&ptr, &name_offset); name_offset = read_u32(&ptr);
if (!(e[i].semantic_name = shader_get_string(data, section->data.size, name_offset))) if (!(e[i].semantic_name = shader_get_string(data, section->data.size, name_offset)))
{ {
WARN("Invalid name offset %#x (data size %#zx).\n", name_offset, section->data.size); WARN("Invalid name offset %#x (data size %#zx).\n", name_offset, section->data.size);
vkd3d_free(e); vkd3d_free(e);
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &e[i].semantic_index); e[i].semantic_index = read_u32(&ptr);
read_dword(&ptr, &e[i].sysval_semantic); e[i].sysval_semantic = read_u32(&ptr);
read_dword(&ptr, &e[i].component_type); e[i].component_type = read_u32(&ptr);
read_dword(&ptr, &e[i].register_index); e[i].register_index = read_u32(&ptr);
e[i].target_location = e[i].register_index; e[i].target_location = e[i].register_index;
e[i].register_count = 1; e[i].register_count = 1;
read_dword(&ptr, &mask); mask = read_u32(&ptr);
e[i].mask = mask & 0xff; e[i].mask = mask & 0xff;
e[i].used_mask = (mask >> 8) & 0xff; e[i].used_mask = (mask >> 8) & 0xff;
switch (section->tag) switch (section->tag)
@ -431,7 +439,7 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
} }
if (has_min_precision) if (has_min_precision)
read_dword(&ptr, &e[i].min_precision); e[i].min_precision = read_u32(&ptr);
else else
e[i].min_precision = VKD3D_SHADER_MINIMUM_PRECISION_NONE; e[i].min_precision = VKD3D_SHADER_MINIMUM_PRECISION_NONE;
@ -597,11 +605,11 @@ static int shader_parse_descriptor_ranges(struct root_signature_parser_context *
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &ranges[i].range_type); ranges[i].range_type = read_u32(&ptr);
read_dword(&ptr, &ranges[i].descriptor_count); ranges[i].descriptor_count = read_u32(&ptr);
read_dword(&ptr, &ranges[i].base_shader_register); ranges[i].base_shader_register = read_u32(&ptr);
read_dword(&ptr, &ranges[i].register_space); ranges[i].register_space = read_u32(&ptr);
read_dword(&ptr, &ranges[i].descriptor_table_offset); ranges[i].descriptor_table_offset = read_u32(&ptr);
TRACE("Type %#x, descriptor count %u, base shader register %u, " TRACE("Type %#x, descriptor count %u, base shader register %u, "
"register space %u, offset %u.\n", "register space %u, offset %u.\n",
@ -640,12 +648,12 @@ static int shader_parse_descriptor_ranges1(struct root_signature_parser_context
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &ranges[i].range_type); ranges[i].range_type = read_u32(&ptr);
read_dword(&ptr, &ranges[i].descriptor_count); ranges[i].descriptor_count = read_u32(&ptr);
read_dword(&ptr, &ranges[i].base_shader_register); ranges[i].base_shader_register = read_u32(&ptr);
read_dword(&ptr, &ranges[i].register_space); ranges[i].register_space = read_u32(&ptr);
read_dword(&ptr, &ranges[i].flags); ranges[i].flags = read_u32(&ptr);
read_dword(&ptr, &ranges[i].descriptor_table_offset); ranges[i].descriptor_table_offset = read_u32(&ptr);
TRACE("Type %#x, descriptor count %u, base shader register %u, " TRACE("Type %#x, descriptor count %u, base shader register %u, "
"register space %u, flags %#x, offset %u.\n", "register space %u, flags %#x, offset %u.\n",
@ -673,8 +681,8 @@ static int shader_parse_descriptor_table(struct root_signature_parser_context *c
} }
ptr = &context->data[offset]; ptr = &context->data[offset];
read_dword(&ptr, &count); count = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Descriptor range count %u.\n", count); TRACE("Descriptor range count %u.\n", count);
@ -700,8 +708,8 @@ static int shader_parse_descriptor_table1(struct root_signature_parser_context *
} }
ptr = &context->data[offset]; ptr = &context->data[offset];
read_dword(&ptr, &count); count = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Descriptor range count %u.\n", count); TRACE("Descriptor range count %u.\n", count);
@ -725,9 +733,9 @@ static int shader_parse_root_constants(struct root_signature_parser_context *con
} }
ptr = &context->data[offset]; ptr = &context->data[offset];
read_dword(&ptr, &constants->shader_register); constants->shader_register = read_u32(&ptr);
read_dword(&ptr, &constants->register_space); constants->register_space = read_u32(&ptr);
read_dword(&ptr, &constants->value_count); constants->value_count = read_u32(&ptr);
TRACE("Shader register %u, register space %u, 32-bit value count %u.\n", TRACE("Shader register %u, register space %u, 32-bit value count %u.\n",
constants->shader_register, constants->register_space, constants->value_count); constants->shader_register, constants->register_space, constants->value_count);
@ -747,8 +755,8 @@ static int shader_parse_root_descriptor(struct root_signature_parser_context *co
} }
ptr = &context->data[offset]; ptr = &context->data[offset];
read_dword(&ptr, &descriptor->shader_register); descriptor->shader_register = read_u32(&ptr);
read_dword(&ptr, &descriptor->register_space); descriptor->register_space = read_u32(&ptr);
TRACE("Shader register %u, register space %u.\n", TRACE("Shader register %u, register space %u.\n",
descriptor->shader_register, descriptor->register_space); descriptor->shader_register, descriptor->register_space);
@ -779,9 +787,9 @@ static int shader_parse_root_descriptor1(struct root_signature_parser_context *c
} }
ptr = &context->data[offset]; ptr = &context->data[offset];
read_dword(&ptr, &descriptor->shader_register); descriptor->shader_register = read_u32(&ptr);
read_dword(&ptr, &descriptor->register_space); descriptor->register_space = read_u32(&ptr);
read_dword(&ptr, &descriptor->flags); descriptor->flags = read_u32(&ptr);
TRACE("Shader register %u, register space %u, flags %#x.\n", TRACE("Shader register %u, register space %u, flags %#x.\n",
descriptor->shader_register, descriptor->register_space, descriptor->flags); descriptor->shader_register, descriptor->register_space, descriptor->flags);
@ -807,9 +815,9 @@ static int shader_parse_root_parameters(struct root_signature_parser_context *co
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &parameters[i].parameter_type); parameters[i].parameter_type = read_u32(&ptr);
read_dword(&ptr, &parameters[i].shader_visibility); parameters[i].shader_visibility = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Type %#x, shader visibility %#x.\n", TRACE("Type %#x, shader visibility %#x.\n",
parameters[i].parameter_type, parameters[i].shader_visibility); parameters[i].parameter_type, parameters[i].shader_visibility);
@ -855,9 +863,9 @@ static int shader_parse_root_parameters1(struct root_signature_parser_context *c
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &parameters[i].parameter_type); parameters[i].parameter_type = read_u32(&ptr);
read_dword(&ptr, &parameters[i].shader_visibility); parameters[i].shader_visibility = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Type %#x, shader visibility %#x.\n", TRACE("Type %#x, shader visibility %#x.\n",
parameters[i].parameter_type, parameters[i].shader_visibility); parameters[i].parameter_type, parameters[i].shader_visibility);
@ -902,19 +910,19 @@ static int shader_parse_static_samplers(struct root_signature_parser_context *co
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &sampler_descs[i].filter); sampler_descs[i].filter = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].address_u); sampler_descs[i].address_u = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].address_v); sampler_descs[i].address_v = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].address_w); sampler_descs[i].address_w = read_u32(&ptr);
read_float(&ptr, &sampler_descs[i].mip_lod_bias); sampler_descs[i].mip_lod_bias = read_float(&ptr);
read_dword(&ptr, &sampler_descs[i].max_anisotropy); sampler_descs[i].max_anisotropy = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].comparison_func); sampler_descs[i].comparison_func = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].border_colour); sampler_descs[i].border_colour = read_u32(&ptr);
read_float(&ptr, &sampler_descs[i].min_lod); sampler_descs[i].min_lod = read_float(&ptr);
read_float(&ptr, &sampler_descs[i].max_lod); sampler_descs[i].max_lod = read_float(&ptr);
read_dword(&ptr, &sampler_descs[i].shader_register); sampler_descs[i].shader_register = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].register_space); sampler_descs[i].register_space = read_u32(&ptr);
read_dword(&ptr, &sampler_descs[i].shader_visibility); sampler_descs[i].shader_visibility = read_u32(&ptr);
} }
return VKD3D_OK; return VKD3D_OK;
@ -938,7 +946,7 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data,
return VKD3D_ERROR_INVALID_ARGUMENT; return VKD3D_ERROR_INVALID_ARGUMENT;
} }
read_dword(&ptr, &version); version = read_u32(&ptr);
TRACE("Version %#x.\n", version); TRACE("Version %#x.\n", version);
if (version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0 && version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1) if (version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0 && version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1)
{ {
@ -947,8 +955,8 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data,
} }
desc->version = version; desc->version = version;
read_dword(&ptr, &count); count = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Parameter count %u, offset %u.\n", count, offset); TRACE("Parameter count %u, offset %u.\n", count, offset);
if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0) if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
@ -982,8 +990,8 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data,
} }
} }
read_dword(&ptr, &count); count = read_u32(&ptr);
read_dword(&ptr, &offset); offset = read_u32(&ptr);
TRACE("Static sampler count %u, offset %u.\n", count, offset); TRACE("Static sampler count %u, offset %u.\n", count, offset);
v_1_0->static_sampler_count = count; v_1_0->static_sampler_count = count;
@ -997,7 +1005,7 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data,
return ret; return ret;
} }
read_dword(&ptr, &v_1_0->flags); v_1_0->flags = read_u32(&ptr);
TRACE("Flags %#x.\n", v_1_0->flags); TRACE("Flags %#x.\n", v_1_0->flags);
return VKD3D_OK; return VKD3D_OK;