Wine-Devel
Threads by month
- ----- 2026 -----
- July
- June
- May
- April
- March
- February
- January
- ----- 2025 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2024 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2007 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2006 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2005 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2004 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2003 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2002 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2001 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- 1 participants
- 84549 discussions
Oct. 1, 2021
Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com>
---
dlls/d3d10/effect.c | 50 ++++++++++++---------
dlls/d3d10/tests/effect.c | 91 +++++++++++++++++++++++++++++++++++++++
2 files changed, 121 insertions(+), 20 deletions(-)
diff --git a/dlls/d3d10/effect.c b/dlls/d3d10/effect.c
index 70a99601eea..8ff7ed53963 100644
--- a/dlls/d3d10/effect.c
+++ b/dlls/d3d10/effect.c
@@ -3973,6 +3973,29 @@ static void update_buffer(ID3D10Device *device, struct d3d10_effect_variable *v)
b->changed = FALSE;
}
+static void set_sampler(ID3D10Device *device, D3D10_SHADER_VARIABLE_TYPE shader_type,
+ struct d3d10_effect_variable *v, unsigned int bind_point)
+{
+ switch (shader_type)
+ {
+ case D3D10_SVT_VERTEXSHADER:
+ ID3D10Device_VSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
+ break;
+
+ case D3D10_SVT_PIXELSHADER:
+ ID3D10Device_PSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
+ break;
+
+ case D3D10_SVT_GEOMETRYSHADER:
+ ID3D10Device_GSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
+ break;
+
+ default:
+ WARN("Incorrect shader type to bind sampler.\n");
+ break;
+ }
+}
+
static void apply_shader_resources(ID3D10Device *device, struct ID3D10EffectShaderVariable *variable)
{
struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(variable);
@@ -3980,7 +4003,7 @@ static void apply_shader_resources(ID3D10Device *device, struct ID3D10EffectShad
struct d3d10_effect_shader_resource *sr;
struct d3d10_effect_variable *rsrc_v;
ID3D10ShaderResourceView **srv;
- unsigned int i;
+ unsigned int i, j;
for (i = 0; i < sv->resource_count; ++i)
{
@@ -4045,27 +4068,14 @@ static void apply_shader_resources(ID3D10Device *device, struct ID3D10EffectShad
break;
case D3D10_SIT_SAMPLER:
- switch (v->type->basetype)
+ if (!rsrc_v->type->element_count)
{
- case D3D10_SVT_VERTEXSHADER:
- ID3D10Device_VSSetSamplers(device, sr->bind_point, sr->bind_count,
- &rsrc_v->u.state.object.sampler);
- break;
-
- case D3D10_SVT_PIXELSHADER:
- ID3D10Device_PSSetSamplers(device, sr->bind_point, sr->bind_count,
- &rsrc_v->u.state.object.sampler);
- break;
-
- case D3D10_SVT_GEOMETRYSHADER:
- ID3D10Device_GSSetSamplers(device, sr->bind_point, sr->bind_count,
- &rsrc_v->u.state.object.sampler);
- break;
-
- default:
- WARN("Incorrect shader type to bind sampler.\n");
- break;
+ set_sampler(device, v->type->basetype, rsrc_v, sr->bind_point);
+ break;
}
+
+ for (j = 0; j < sr->bind_count; ++j)
+ set_sampler(device, v->type->basetype, &rsrc_v->elements[j], sr->bind_point + j);
break;
default:
diff --git a/dlls/d3d10/tests/effect.c b/dlls/d3d10/tests/effect.c
index 60be8186f8b..f7b536b2fb0 100644
--- a/dlls/d3d10/tests/effect.c
+++ b/dlls/d3d10/tests/effect.c
@@ -5769,6 +5769,55 @@ static DWORD fx_test_resource_variable[] =
0x00070000, 0x02120000, 0x00070000, 0x00000000, 0x00070000, 0x057a0000, 0x00000000,
};
+#if 0
+Texture2D t_a[2];
+
+SamplerState s[2] : register(s1);
+
+float4 PS( float4 pos : SV_POSITION ) : SV_Target
+{
+ return t_a[1].Sample(s[1], float2(0, 0));
+}
+
+technique10 rsrc_test
+{
+ pass p0
+ {
+ SetPixelShader(CompileShader(ps_4_0, PS()));
+ }
+}
+#endif
+static DWORD fx_test_resource_variable2[] =
+{
+ 0x43425844, 0xb62313ac, 0x8116090b, 0xdc1d2951, 0xfc18ca42, 0x00000001, 0x0000035a, 0x00000001,
+ 0x00000024, 0x30315846, 0x0000032e, 0xfeff1001, 0x00000000, 0x00000000, 0x00000002, 0x00000000,
+ 0x00000000, 0x00000000, 0x00000001, 0x0000028a, 0x00000000, 0x00000002, 0x00000000, 0x00000000,
+ 0x00000000, 0x00000002, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x74786554,
+ 0x32657275, 0x00040044, 0x00020000, 0x00020000, 0x00000000, 0x00000000, 0x00000000, 0x000c0000,
+ 0x5f740000, 0x61530061, 0x656c706d, 0x61745372, 0x2e006574, 0x02000000, 0x02000000, 0x00000000,
+ 0x00000000, 0x00000000, 0x15000000, 0x73000000, 0x72737200, 0x65745f63, 0x70007473, 0x02180030,
+ 0x58440000, 0xb2424342, 0x3c889e83, 0xb8b8fc18, 0x749f2920, 0x0001877a, 0x02180000, 0x00050000,
+ 0x00340000, 0x00c80000, 0x00fc0000, 0x01300000, 0x019c0000, 0x44520000, 0x008c4645, 0x00000000,
+ 0x00000000, 0x00020000, 0x001c0000, 0x04000000, 0x0100ffff, 0x00620000, 0x005c0000, 0x00030000,
+ 0x00000000, 0x00000000, 0x00000000, 0x00010000, 0x00020000, 0x00010000, 0x005e0000, 0x00020000,
+ 0x00050000, 0x00040000, 0xffff0000, 0x0000ffff, 0x00020000, 0x000c0000, 0x00730000, 0x00615f74,
+ 0x7263694d, 0x666f736f, 0x52282074, 0x4c482029, 0x53204c53, 0x65646168, 0x6f432072, 0x6c69706d,
+ 0x31207265, 0x00312e30, 0x5349abab, 0x002c4e47, 0x00010000, 0x00080000, 0x00200000, 0x00000000,
+ 0x00010000, 0x00030000, 0x00000000, 0x000f0000, 0x56530000, 0x534f505f, 0x4f495449, 0x534f004e,
+ 0x002c4e47, 0x00010000, 0x00080000, 0x00200000, 0x00000000, 0x00000000, 0x00030000, 0x00000000,
+ 0x000f0000, 0x56530000, 0x7261545f, 0x00746567, 0x4853abab, 0x00645244, 0x00400000, 0x00190000,
+ 0x005a0000, 0x60000300, 0x00020010, 0x18580000, 0x70000400, 0x00010010, 0x55550000, 0x00650000,
+ 0x20f20300, 0x00000010, 0x00450000, 0x20f20c00, 0x00000010, 0x40020000, 0x00000000, 0x00000000,
+ 0x00000000, 0x00000000, 0x7e460000, 0x00010010, 0x60000000, 0x00020010, 0x003e0000, 0x54530100,
+ 0x00745441, 0x00020000, 0x00000000, 0x00000000, 0x00010000, 0x00000000, 0x00000000, 0x00000000,
+ 0x00010000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00010000,
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00660000, 0x00000000,
+ 0x002a0000, 0x000e0000, 0x00000000, 0xffff0000, 0x0000ffff, 0x00570000, 0x003b0000, 0x00000000,
+ 0xffff0000, 0x0000ffff, 0x00000000, 0x00000000, 0x00590000, 0x00010000, 0x00000000, 0x00630000,
+ 0x00010000, 0x00000000, 0x00070000, 0x00000000, 0x00070000, 0x02820000, 0x00000000,
+};
+
static void create_effect_texture_resource(ID3D10Device *device, ID3D10ShaderResourceView **srv,
ID3D10Texture2D **tex)
{
@@ -5812,10 +5861,13 @@ static ID3D10EffectShaderResourceVariable *get_effect_shader_resource_variable_(
static void test_effect_resource_variable(void)
{
+ ID3D10SamplerState *samplers[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT];
ID3D10ShaderResourceView *srv0, *srv_a[2], *srv_tmp[2];
ID3D10EffectShaderResourceVariable *t0, *t_a, *t_a_0;
ID3D10EffectTechnique *technique;
ID3D10Texture2D *tex0, *tex_a[2];
+ ID3D10EffectSamplerVariable *s;
+ ID3D10SamplerState *sampler[2];
D3D10_EFFECT_DESC effect_desc;
D3D10_PASS_DESC pass_desc;
ID3D10EffectVariable *var;
@@ -5938,6 +5990,45 @@ static void test_effect_resource_variable(void)
effect->lpVtbl->Release(effect);
+ hr = create_effect(fx_test_resource_variable2, 0, device, NULL, &effect);
+ ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
+
+ technique = effect->lpVtbl->GetTechniqueByName(effect, "rsrc_test");
+ ok(!!technique, "Got unexpected technique %p.\n", technique);
+ pass = technique->lpVtbl->GetPassByName(technique, "p0");
+ ok(!!pass, "Got unexpected pass %p.\n", pass);
+
+ var = effect->lpVtbl->GetVariableByName(effect, "s");
+ ok(var->lpVtbl->IsValid(var), "Expected valid variable.\n");
+
+ s = var->lpVtbl->AsSampler(var);
+ ok(s->lpVtbl->IsValid(s), "Expected valid sample variable.\n");
+
+ hr = s->lpVtbl->GetSampler(s, 0, &sampler[0]);
+ ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
+ hr = s->lpVtbl->GetSampler(s, 1, &sampler[1]);
+ ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
+
+ hr = pass->lpVtbl->Apply(pass, 0);
+ ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
+
+ ID3D10Device_PSGetSamplers(device, 0, ARRAY_SIZE(samplers), samplers);
+ for (i = 0; i < ARRAY_SIZE(samplers); ++i)
+ {
+ if (i == 1 || i == 2)
+ {
+ ok(samplers[i] == sampler[i - 1], "Unexpected sampler at %u.\n", i);
+ }
+ else
+ ok(!samplers[i], "Unexpected sampler at %u.\n", i);
+ if (samplers[i])
+ ID3D10SamplerState_Release(samplers[i]);
+ }
+ for (i = 0; i < ARRAY_SIZE(sampler); ++i)
+ ID3D10SamplerState_Release(sampler[i]);
+
+ effect->lpVtbl->Release(effect);
+
refcount = ID3D10Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
--
2.33.0
3
20
Fixes PE-only builds with llvm-mingw. The option is not relevant on
mingw. While mingw GCC ignores it, Clags issues an error.
Signed-off-by: Jacek Caban <jacek(a)codeweavers.com>
---
configure.ac | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
2
3
[PATCH vkd3d 5/5] vkd3d-shader/sm4: Maintain the parser location in the vkd3d_shader_parser structure.
by Henri Verbeet Oct. 1, 2021
by Henri Verbeet Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
libs/vkd3d-shader/dxbc.c | 11 +++++++----
libs/vkd3d-shader/glsl.c | 14 ++++----------
libs/vkd3d-shader/spirv.c | 10 ++++------
libs/vkd3d-shader/vkd3d_shader_main.c | 13 +++++++++----
libs/vkd3d-shader/vkd3d_shader_private.h | 21 +++++++++++----------
5 files changed, 35 insertions(+), 34 deletions(-)
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index cc5b1b8d..f6d99ea6 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -970,8 +970,9 @@ static enum vkd3d_data_type map_data_type(char t)
}
}
-static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t *byte_code, size_t byte_code_size,
- const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context)
+static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t *byte_code,
+ size_t byte_code_size, const char *source_name, const struct vkd3d_shader_signature *output_signature,
+ struct vkd3d_shader_message_context *message_context)
{
struct vkd3d_shader_version version;
uint32_t version_token, token_count;
@@ -1029,7 +1030,7 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t
version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
- vkd3d_shader_parser_init(&sm4->p, message_context, &version);
+ vkd3d_shader_parser_init(&sm4->p, message_context, source_name, &version);
sm4->p.ptr = sm4->start;
memset(sm4->output_map, 0xff, sizeof(sm4->output_map));
@@ -1550,6 +1551,8 @@ void shader_sm4_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3
}
remaining = sm4->end - *ptr;
+ ++parser->location.line;
+
opcode_token = *(*ptr)++;
opcode = opcode_token & VKD3D_SM4_OPCODE_MASK;
@@ -1687,7 +1690,7 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi
}
if (!shader_sm4_init(sm4, shader_desc->byte_code, shader_desc->byte_code_size,
- &shader_desc->output_signature, message_context))
+ compile_info->source_name, &shader_desc->output_signature, message_context))
{
WARN("Failed to initialise shader parser.\n");
free_shader_desc(shader_desc);
diff --git a/libs/vkd3d-shader/glsl.c b/libs/vkd3d-shader/glsl.c
index 7e028d23..9858098b 100644
--- a/libs/vkd3d-shader/glsl.c
+++ b/libs/vkd3d-shader/glsl.c
@@ -22,14 +22,13 @@ struct vkd3d_glsl_generator
{
struct vkd3d_shader_version version;
struct vkd3d_string_buffer buffer;
- struct vkd3d_shader_location location;
+ const struct vkd3d_shader_location *location;
struct vkd3d_shader_message_context *message_context;
bool failed;
};
struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_version *version,
- const struct vkd3d_shader_compile_info *compile_info,
- struct vkd3d_shader_message_context *message_context)
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location)
{
struct vkd3d_glsl_generator *generator;
@@ -39,8 +38,7 @@ struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shad
memset(generator, 0, sizeof(*generator));
generator->version = *version;
vkd3d_string_buffer_init(&generator->buffer);
- generator->location.source_name = compile_info->source_name;
- generator->location.line = 2; /* Line 1 is the version token. */
+ generator->location = location;
generator->message_context = message_context;
return generator;
}
@@ -52,10 +50,9 @@ static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_glsl_compiler_error(
va_list args;
va_start(args, fmt);
- vkd3d_shader_verror(generator->message_context, &generator->location, error, fmt, args);
+ vkd3d_shader_verror(generator->message_context, generator->location, error, fmt, args);
va_end(args);
generator->failed = true;
- return;
}
static void shader_glsl_ret(struct vkd3d_glsl_generator *generator,
@@ -91,9 +88,6 @@ static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *generator
"Unhandled instruction %#x", instruction->handler_idx);
break;
}
-
- ++generator->location.line;
- return;
}
int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator,
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index f604b8ef..0be17e39 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -2208,7 +2208,7 @@ struct vkd3d_dxbc_compiler
struct vkd3d_spirv_builder spirv_builder;
struct vkd3d_shader_message_context *message_context;
- struct vkd3d_shader_location location;
+ const struct vkd3d_shader_location *location;
bool failed;
bool strip_debug;
@@ -2286,7 +2286,7 @@ static const char *vkd3d_dxbc_compiler_get_entry_point_name(const struct vkd3d_d
struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version,
const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info,
const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info,
- struct vkd3d_shader_message_context *message_context)
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location)
{
const struct vkd3d_shader_signature *patch_constant_signature = &shader_desc->patch_constant_signature;
const struct vkd3d_shader_signature *output_signature = &shader_desc->output_signature;
@@ -2301,8 +2301,7 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader
memset(compiler, 0, sizeof(*compiler));
compiler->message_context = message_context;
- compiler->location.source_name = compile_info->source_name;
- compiler->location.line = 2; /* Line 1 is the version token. */
+ compiler->location = location;
if ((target_info = vkd3d_find_struct(compile_info->next, SPIRV_TARGET_INFO)))
{
@@ -2518,7 +2517,7 @@ static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_dxbc_compiler_error(struct vkd3d_dxbc_
va_list args;
va_start(args, format);
- vkd3d_shader_verror(compiler->message_context, &compiler->location, error, format, args);
+ vkd3d_shader_verror(compiler->message_context, compiler->location, error, format, args);
va_end(args);
compiler->failed = true;
}
@@ -9747,7 +9746,6 @@ int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler,
FIXME("Unhandled instruction %#x.\n", instruction->handler_idx);
}
- ++compiler->location.line;
return ret;
}
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index ef3ed955..c566ac3d 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -373,9 +373,13 @@ void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type,
}
void vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
- struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_version *version)
+ struct vkd3d_shader_message_context *message_context, const char *source_name,
+ const struct vkd3d_shader_version *version)
{
parser->message_context = message_context;
+ parser->location.source_name = source_name;
+ parser->location.line = 1;
+ parser->location.column = 0;
parser->shader_version = *version;
}
@@ -1049,7 +1053,8 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
{
struct vkd3d_glsl_generator *glsl_generator;
- if (!(glsl_generator = vkd3d_glsl_generator_create(&parser->shader_version, compile_info, message_context)))
+ if (!(glsl_generator = vkd3d_glsl_generator_create(&parser->shader_version,
+ message_context, &parser->location)))
{
ERR("Failed to create GLSL generator.\n");
vkd3d_shader_parser_destroy(parser);
@@ -1065,8 +1070,8 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
return ret;
}
- if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser->shader_version,
- &parser->shader_desc, compile_info, &scan_descriptor_info, message_context)))
+ if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser->shader_version, &parser->shader_desc,
+ compile_info, &scan_descriptor_info, message_context, &parser->location)))
{
ERR("Failed to create DXBC compiler.\n");
vkd3d_shader_parser_destroy(parser);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 87d21381..0f1967bf 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -887,9 +887,16 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg
return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT;
}
+struct vkd3d_shader_location
+{
+ const char *source_name;
+ unsigned int line, column;
+};
+
struct vkd3d_shader_parser
{
struct vkd3d_shader_message_context *message_context;
+ struct vkd3d_shader_location location;
struct vkd3d_shader_desc shader_desc;
struct vkd3d_shader_version shader_version;
@@ -897,7 +904,8 @@ struct vkd3d_shader_parser
};
void vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
- struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_version *version);
+ struct vkd3d_shader_message_context *message_context, const char *source_name,
+ const struct vkd3d_shader_version *version);
void vkd3d_shader_trace(struct vkd3d_shader_parser *parser);
@@ -967,12 +975,6 @@ static inline size_t bytecode_get_size(struct vkd3d_bytecode_buffer *buffer)
return buffer->size;
}
-struct vkd3d_shader_location
-{
- const char *source_name;
- unsigned int line, column;
-};
-
struct vkd3d_shader_message_context
{
enum vkd3d_shader_log_level log_level;
@@ -1015,8 +1017,7 @@ int shader_parse_input_signature(const void *dxbc, size_t dxbc_length,
struct vkd3d_glsl_generator;
struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_version *version,
- const struct vkd3d_shader_compile_info *compile_info,
- struct vkd3d_shader_message_context *message_context);
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location);
int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator,
struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *out);
void vkd3d_glsl_generator_destroy(struct vkd3d_glsl_generator *generator);
@@ -1026,7 +1027,7 @@ struct vkd3d_dxbc_compiler;
struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version,
const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info,
const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info,
- struct vkd3d_shader_message_context *message_context);
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location);
int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction);
int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
--
2.20.1
1
0
[PATCH vkd3d 4/5] vkd3d-shader/sm4: Store the message context pointer in the vkd3d_shader_parser structure.
by Henri Verbeet Oct. 1, 2021
by Henri Verbeet Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
libs/vkd3d-shader/dxbc.c | 26 ++++++++++++------------
libs/vkd3d-shader/vkd3d_shader_main.c | 7 +++++++
libs/vkd3d-shader/vkd3d_shader_private.h | 5 +++++
3 files changed, 25 insertions(+), 13 deletions(-)
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index b93d6181..cc5b1b8d 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -97,7 +97,6 @@ struct vkd3d_shader_sm4_parser
struct list src;
struct vkd3d_shader_immediate_constant_buffer icb;
- struct vkd3d_shader_message_context *message_context;
struct vkd3d_shader_parser p;
};
@@ -176,13 +175,13 @@ static bool shader_is_sm_5_1(const struct vkd3d_shader_sm4_parser *sm4)
return version->major >= 5 && version->minor >= 1;
}
-static void VKD3D_PRINTF_FUNC(3, 4) shader_sm4_error(struct vkd3d_shader_sm4_parser *priv,
+static void VKD3D_PRINTF_FUNC(3, 4) shader_sm4_error(struct vkd3d_shader_sm4_parser *sm4,
enum vkd3d_shader_error error, const char *format, ...)
{
va_list args;
va_start(args, format);
- vkd3d_shader_verror(priv->message_context, NULL, error, format, args);
+ vkd3d_shader_verror(sm4->p.message_context, NULL, error, format, args);
va_end(args);
}
@@ -974,6 +973,7 @@ static enum vkd3d_data_type map_data_type(char t)
static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t *byte_code, size_t byte_code_size,
const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context)
{
+ struct vkd3d_shader_version version;
uint32_t version_token, token_count;
unsigned int i;
@@ -1000,34 +1000,36 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t
switch (version_token >> 16)
{
case VKD3D_SM4_PS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_PIXEL;
+ version.type = VKD3D_SHADER_TYPE_PIXEL;
break;
case VKD3D_SM4_VS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_VERTEX;
+ version.type = VKD3D_SHADER_TYPE_VERTEX;
break;
case VKD3D_SM4_GS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_GEOMETRY;
+ version.type = VKD3D_SHADER_TYPE_GEOMETRY;
break;
case VKD3D_SM5_HS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_HULL;
+ version.type = VKD3D_SHADER_TYPE_HULL;
break;
case VKD3D_SM5_DS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_DOMAIN;
+ version.type = VKD3D_SHADER_TYPE_DOMAIN;
break;
case VKD3D_SM5_CS:
- sm4->p.shader_version.type = VKD3D_SHADER_TYPE_COMPUTE;
+ version.type = VKD3D_SHADER_TYPE_COMPUTE;
break;
default:
FIXME("Unrecognised shader type %#x.\n", version_token >> 16);
}
- sm4->p.shader_version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
- sm4->p.shader_version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
+ version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
+ version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
+
+ vkd3d_shader_parser_init(&sm4->p, message_context, &version);
sm4->p.ptr = sm4->start;
memset(sm4->output_map, 0xff, sizeof(sm4->output_map));
@@ -1047,8 +1049,6 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t
list_init(&sm4->src_free);
list_init(&sm4->src);
- sm4->message_context = message_context;
-
return true;
}
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index f253e479..ef3ed955 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -372,6 +372,13 @@ void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type,
shader_get_source_type_suffix(source_type), shader->code, shader->size);
}
+void vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_version *version)
+{
+ parser->message_context = message_context;
+ parser->shader_version = *version;
+}
+
static void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser)
{
shader_sm4_free(parser);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 905b5200..87d21381 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -889,11 +889,16 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg
struct vkd3d_shader_parser
{
+ struct vkd3d_shader_message_context *message_context;
+
struct vkd3d_shader_desc shader_desc;
struct vkd3d_shader_version shader_version;
const uint32_t *ptr;
};
+void vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
+ struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_version *version);
+
void vkd3d_shader_trace(struct vkd3d_shader_parser *parser);
const char *shader_get_type_prefix(enum vkd3d_shader_type type);
--
2.20.1
1
0
[PATCH vkd3d 3/5] vkd3d-shader/sm4: Get rid of the redundant "shader_version" field in the vkd3d_shader_sm4_parser structure.
by Henri Verbeet Oct. 1, 2021
by Henri Verbeet Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
libs/vkd3d-shader/dxbc.c | 40 ++++++++++--------------
libs/vkd3d-shader/trace.c | 3 +-
libs/vkd3d-shader/vkd3d_shader_private.h | 1 -
3 files changed, 18 insertions(+), 26 deletions(-)
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index 0c2647e8..b93d6181 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -87,7 +87,6 @@ struct vkd3d_shader_src_param_entry
struct vkd3d_shader_sm4_parser
{
- struct vkd3d_shader_version shader_version;
const DWORD *start, *end;
unsigned int output_map[MAX_REG_OUTPUT];
@@ -170,9 +169,10 @@ static struct vkd3d_shader_sm4_parser *vkd3d_shader_sm4_parser(struct vkd3d_shad
return CONTAINING_RECORD(parser, struct vkd3d_shader_sm4_parser, p);
}
-static bool shader_is_sm_5_1(const struct vkd3d_shader_sm4_parser *priv)
+static bool shader_is_sm_5_1(const struct vkd3d_shader_sm4_parser *sm4)
{
- const struct vkd3d_shader_version *version = &priv->shader_version;
+ const struct vkd3d_shader_version *version = &sm4->p.shader_version;
+
return version->major >= 5 && version->minor >= 1;
}
@@ -920,23 +920,23 @@ static const struct vkd3d_sm4_opcode_info *get_opcode_info(enum vkd3d_sm4_opcode
return NULL;
}
-static void map_register(const struct vkd3d_shader_sm4_parser *priv, struct vkd3d_shader_register *reg)
+static void map_register(const struct vkd3d_shader_sm4_parser *sm4, struct vkd3d_shader_register *reg)
{
- switch (priv->shader_version.type)
+ switch (sm4->p.shader_version.type)
{
case VKD3D_SHADER_TYPE_PIXEL:
if (reg->type == VKD3DSPR_OUTPUT)
{
unsigned int reg_idx = reg->idx[0].offset;
- if (reg_idx >= ARRAY_SIZE(priv->output_map))
+ if (reg_idx >= ARRAY_SIZE(sm4->output_map))
{
ERR("Invalid output index %u.\n", reg_idx);
break;
}
reg->type = VKD3DSPR_COLOROUT;
- reg->idx[0].offset = priv->output_map[reg_idx];
+ reg->idx[0].offset = sm4->output_map[reg_idx];
}
break;
@@ -1000,34 +1000,35 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t
switch (version_token >> 16)
{
case VKD3D_SM4_PS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_PIXEL;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_PIXEL;
break;
case VKD3D_SM4_VS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_VERTEX;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_VERTEX;
break;
case VKD3D_SM4_GS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_GEOMETRY;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_GEOMETRY;
break;
case VKD3D_SM5_HS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_HULL;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_HULL;
break;
case VKD3D_SM5_DS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_DOMAIN;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_DOMAIN;
break;
case VKD3D_SM5_CS:
- sm4->shader_version.type = VKD3D_SHADER_TYPE_COMPUTE;
+ sm4->p.shader_version.type = VKD3D_SHADER_TYPE_COMPUTE;
break;
default:
FIXME("Unrecognised shader type %#x.\n", version_token >> 16);
}
- sm4->shader_version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
- sm4->shader_version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
+ sm4->p.shader_version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
+ sm4->p.shader_version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
+ sm4->p.ptr = sm4->start;
memset(sm4->output_map, 0xff, sizeof(sm4->output_map));
for (i = 0; i < output_signature->element_count; ++i)
@@ -1087,14 +1088,6 @@ static struct vkd3d_shader_src_param *get_src_param(struct vkd3d_shader_sm4_pars
return &e->param;
}
-void shader_sm4_read_header(struct vkd3d_shader_parser *parser, struct vkd3d_shader_version *shader_version)
-{
- struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
-
- parser->ptr = sm4->start;
- *shader_version = sm4->shader_version;
-}
-
static bool shader_sm4_read_reg_idx(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
const uint32_t *end, uint32_t addressing, struct vkd3d_shader_register_index *reg_idx)
{
@@ -1702,7 +1695,6 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi
return VKD3D_ERROR_INVALID_ARGUMENT;
}
- shader_sm4_read_header(&sm4->p, &sm4->p.shader_version);
*parser = &sm4->p;
return VKD3D_OK;
diff --git a/libs/vkd3d-shader/trace.c b/libs/vkd3d-shader/trace.c
index 45f38d13..2858c7f9 100644
--- a/libs/vkd3d-shader/trace.c
+++ b/libs/vkd3d-shader/trace.c
@@ -1883,12 +1883,13 @@ enum vkd3d_result vkd3d_dxbc_binary_to_text(struct vkd3d_shader_parser *parser,
vkd3d_string_buffer_init(buffer);
shader_version = &compiler.shader_version;
- shader_sm4_read_header(parser, shader_version);
+ *shader_version = parser->shader_version;
vkd3d_string_buffer_printf(buffer, "%s%s_%u_%u%s\n", compiler.colours.version,
shader_get_type_prefix(shader_version->type), shader_version->major,
shader_version->minor, compiler.colours.reset);
indent = 0;
+ shader_sm4_reset(parser);
while (!shader_sm4_is_end(parser))
{
struct vkd3d_shader_instruction ins;
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 0ac5ecef..905b5200 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -901,7 +901,6 @@ const char *shader_get_type_prefix(enum vkd3d_shader_type type);
struct vkd3d_shader_message_context;
void shader_sm4_free(struct vkd3d_shader_parser *parser);
-void shader_sm4_read_header(struct vkd3d_shader_parser *parser, struct vkd3d_shader_version *shader_version);
void shader_sm4_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins);
bool shader_sm4_is_end(struct vkd3d_shader_parser *parser);
void shader_sm4_reset(struct vkd3d_shader_parser *parser);
--
2.20.1
1
0
[PATCH vkd3d 2/5] vkd3d-shader/sm4: Rename the vkd3d_sm4_data structure to vkd3d_shader_sm4_parser.
by Henri Verbeet Oct. 1, 2021
by Henri Verbeet Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
libs/vkd3d-shader/dxbc.c | 226 +++++++++++++++++----------------------
1 file changed, 96 insertions(+), 130 deletions(-)
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index da919b1d..0c2647e8 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -85,7 +85,7 @@ struct vkd3d_shader_src_param_entry
struct vkd3d_shader_src_param param;
};
-struct vkd3d_sm4_data
+struct vkd3d_shader_sm4_parser
{
struct vkd3d_shader_version shader_version;
const DWORD *start, *end;
@@ -108,9 +108,8 @@ struct vkd3d_sm4_opcode_info
enum vkd3d_shader_opcode handler_idx;
const char *dst_info;
const char *src_info;
- void (*read_opcode_func)(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv);
+ void (*read_opcode_func)(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv);
};
static const enum vkd3d_primitive_type output_primitive_type_table[] =
@@ -166,18 +165,18 @@ static const enum vkd3d_data_type data_type_table[] =
/* VKD3D_SM4_DATA_UNUSED */ VKD3D_DATA_UNUSED,
};
-static struct vkd3d_sm4_data *vkd3d_sm4_data(struct vkd3d_shader_parser *parser)
+static struct vkd3d_shader_sm4_parser *vkd3d_shader_sm4_parser(struct vkd3d_shader_parser *parser)
{
- return CONTAINING_RECORD(parser, struct vkd3d_sm4_data, p);
+ return CONTAINING_RECORD(parser, struct vkd3d_shader_sm4_parser, p);
}
-static bool shader_is_sm_5_1(const struct vkd3d_sm4_data *priv)
+static bool shader_is_sm_5_1(const struct vkd3d_shader_sm4_parser *priv)
{
const struct vkd3d_shader_version *version = &priv->shader_version;
return version->major >= 5 && version->minor >= 1;
}
-static void VKD3D_PRINTF_FUNC(3, 4) shader_sm4_error(struct vkd3d_sm4_data *priv,
+static void VKD3D_PRINTF_FUNC(3, 4) shader_sm4_error(struct vkd3d_shader_sm4_parser *priv,
enum vkd3d_shader_error error, const char *format, ...)
{
va_list args;
@@ -187,13 +186,13 @@ static void VKD3D_PRINTF_FUNC(3, 4) shader_sm4_error(struct vkd3d_sm4_data *priv
va_end(args);
}
-static bool shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- enum vkd3d_data_type data_type, struct vkd3d_shader_src_param *src_param);
-static bool shader_sm4_read_dst_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- enum vkd3d_data_type data_type, struct vkd3d_shader_dst_param *dst_param);
+static bool shader_sm4_read_src_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
+ const uint32_t *end, enum vkd3d_data_type data_type, struct vkd3d_shader_src_param *src_param);
+static bool shader_sm4_read_dst_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
+ const uint32_t *end, enum vkd3d_data_type data_type, struct vkd3d_shader_dst_param *dst_param);
-static bool shader_sm4_read_register_space(struct vkd3d_sm4_data *priv,
- const DWORD **ptr, const DWORD *end, unsigned int *register_space)
+static bool shader_sm4_read_register_space(struct vkd3d_shader_sm4_parser *priv,
+ const uint32_t **ptr, const uint32_t *end, unsigned int *register_space)
{
*register_space = 0;
@@ -210,18 +209,16 @@ static bool shader_sm4_read_register_space(struct vkd3d_sm4_data *priv,
return true;
}
-static void shader_sm4_read_conditional_op(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_conditional_op(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_UINT, &priv->src_param[0]);
ins->flags = (opcode_token & VKD3D_SM4_CONDITIONAL_NZ) ?
VKD3D_SHADER_CONDITIONAL_OP_NZ : VKD3D_SHADER_CONDITIONAL_OP_Z;
}
-static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
enum vkd3d_sm4_shader_data_type type;
unsigned int icb_size;
@@ -248,7 +245,7 @@ static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins,
ins->declaration.icb = &priv->icb;
}
-static void shader_sm4_set_descriptor_register_range(struct vkd3d_sm4_data *priv,
+static void shader_sm4_set_descriptor_register_range(struct vkd3d_shader_sm4_parser *priv,
struct vkd3d_shader_register *reg, struct vkd3d_shader_register_range *range)
{
range->first = reg->idx[1].offset;
@@ -261,9 +258,8 @@ static void shader_sm4_set_descriptor_register_range(struct vkd3d_sm4_data *priv
}
}
-static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_semantic *semantic = &ins->declaration.semantic;
enum vkd3d_sm4_resource_type resource_type;
@@ -309,9 +305,8 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins,
shader_sm4_read_register_space(priv, &tokens, end, &semantic->resource.range.space);
}
-static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
const DWORD *end = &tokens[token_count];
@@ -336,9 +331,8 @@ static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction
}
}
-static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
const DWORD *end = &tokens[token_count];
@@ -350,18 +344,16 @@ static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins,
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.sampler.range.space);
}
-static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_OPAQUE,
&ins->declaration.index_range.dst);
ins->declaration.index_range.register_count = *tokens;
}
-static void shader_sm4_read_dcl_output_topology(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_output_topology(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
enum vkd3d_sm4_output_primitive_type primitive_type;
@@ -375,9 +367,8 @@ static void shader_sm4_read_dcl_output_topology(struct vkd3d_shader_instruction
FIXME("Unhandled output primitive type %#x.\n", primitive_type);
}
-static void shader_sm4_read_dcl_input_primitive(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_input_primitive(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
enum vkd3d_sm4_input_primitive_type primitive_type;
@@ -400,40 +391,35 @@ static void shader_sm4_read_dcl_input_primitive(struct vkd3d_shader_instruction
FIXME("Unhandled input primitive type %#x.\n", primitive_type);
}
-static void shader_sm4_read_declaration_count(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_declaration_count(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.count = *tokens;
}
-static void shader_sm4_read_declaration_dst(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_declaration_dst(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, &ins->declaration.dst);
}
-static void shader_sm4_read_declaration_register_semantic(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_declaration_register_semantic(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT,
&ins->declaration.register_semantic.reg);
ins->declaration.register_semantic.sysval_semantic = *tokens;
}
-static void shader_sm4_read_dcl_input_ps(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_input_ps(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->flags = (opcode_token & VKD3D_SM4_INTERPOLATION_MODE_MASK) >> VKD3D_SM4_INTERPOLATION_MODE_SHIFT;
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, &ins->declaration.dst);
}
-static void shader_sm4_read_dcl_input_ps_siv(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_input_ps_siv(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->flags = (opcode_token & VKD3D_SM4_INTERPOLATION_MODE_MASK) >> VKD3D_SM4_INTERPOLATION_MODE_SHIFT;
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT,
@@ -441,48 +427,42 @@ static void shader_sm4_read_dcl_input_ps_siv(struct vkd3d_shader_instruction *in
ins->declaration.register_semantic.sysval_semantic = *tokens;
}
-static void shader_sm4_read_dcl_indexable_temp(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_indexable_temp(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.indexable_temp.register_idx = *tokens++;
ins->declaration.indexable_temp.register_size = *tokens++;
ins->declaration.indexable_temp.component_count = *tokens;
}
-static void shader_sm4_read_dcl_global_flags(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm4_read_dcl_global_flags(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->flags = (opcode_token & VKD3D_SM4_GLOBAL_FLAGS_MASK) >> VKD3D_SM4_GLOBAL_FLAGS_SHIFT;
}
-static void shader_sm5_read_fcall(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_fcall(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
priv->src_param[0].reg.u.fp_body_idx = *tokens++;
shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_OPAQUE, &priv->src_param[0]);
}
-static void shader_sm5_read_dcl_function_body(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_function_body(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.index = *tokens;
}
-static void shader_sm5_read_dcl_function_table(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_function_table(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.index = *tokens++;
FIXME("Ignoring set of function bodies (count %u).\n", *tokens);
}
-static void shader_sm5_read_dcl_interface(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_interface(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.fp.index = *tokens++;
ins->declaration.fp.body_count = *tokens++;
@@ -491,57 +471,50 @@ static void shader_sm5_read_dcl_interface(struct vkd3d_shader_instruction *ins,
FIXME("Ignoring set of function tables (count %u).\n", ins->declaration.fp.table_count);
}
-static void shader_sm5_read_control_point_count(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_control_point_count(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.count = (opcode_token & VKD3D_SM5_CONTROL_POINT_COUNT_MASK)
>> VKD3D_SM5_CONTROL_POINT_COUNT_SHIFT;
}
-static void shader_sm5_read_dcl_tessellator_domain(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_tessellator_domain(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.tessellator_domain = (opcode_token & VKD3D_SM5_TESSELLATOR_MASK)
- >> VKD3D_SM5_TESSELLATOR_SHIFT;
+ >> VKD3D_SM5_TESSELLATOR_SHIFT;
}
-static void shader_sm5_read_dcl_tessellator_partitioning(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_tessellator_partitioning(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.tessellator_partitioning = (opcode_token & VKD3D_SM5_TESSELLATOR_MASK)
>> VKD3D_SM5_TESSELLATOR_SHIFT;
}
-static void shader_sm5_read_dcl_tessellator_output_primitive(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_tessellator_output_primitive(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.tessellator_output_primitive = (opcode_token & VKD3D_SM5_TESSELLATOR_MASK)
>> VKD3D_SM5_TESSELLATOR_SHIFT;
}
-static void shader_sm5_read_dcl_hs_max_tessfactor(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_hs_max_tessfactor(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.max_tessellation_factor = *(float *)tokens;
}
-static void shader_sm5_read_dcl_thread_group(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_thread_group(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->declaration.thread_group_size.x = *tokens++;
ins->declaration.thread_group_size.y = *tokens++;
ins->declaration.thread_group_size.z = *tokens++;
}
-static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource;
const DWORD *end = &tokens[token_count];
@@ -552,9 +525,8 @@ static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins,
shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.range.space);
}
-static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource;
const DWORD *end = &tokens[token_count];
@@ -568,9 +540,8 @@ static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *
shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.range.space);
}
-static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, &ins->declaration.tgsm_raw.reg);
ins->declaration.tgsm_raw.byte_count = *tokens;
@@ -578,9 +549,8 @@ static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins,
FIXME("Byte count %u is not multiple of 4.\n", ins->declaration.tgsm_raw.byte_count);
}
-static void shader_sm5_read_dcl_tgsm_structured(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_tgsm_structured(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT,
&ins->declaration.tgsm_structured.reg);
@@ -590,9 +560,8 @@ static void shader_sm5_read_dcl_tgsm_structured(struct vkd3d_shader_instruction
FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.tgsm_structured.byte_stride);
}
-static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource;
const DWORD *end = &tokens[token_count];
@@ -605,9 +574,8 @@ static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruct
shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.range.space);
}
-static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins, uint32_t opcode,
+ uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource;
const DWORD *end = &tokens[token_count];
@@ -617,9 +585,8 @@ static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *in
shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.range.space);
}
-static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins,
- DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
- struct vkd3d_sm4_data *priv)
+static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
+ const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
{
ins->flags = (opcode_token & VKD3D_SM5_SYNC_FLAGS_MASK) >> VKD3D_SM5_SYNC_FLAGS_SHIFT;
}
@@ -953,7 +920,7 @@ static const struct vkd3d_sm4_opcode_info *get_opcode_info(enum vkd3d_sm4_opcode
return NULL;
}
-static void map_register(const struct vkd3d_sm4_data *priv, struct vkd3d_shader_register *reg)
+static void map_register(const struct vkd3d_shader_sm4_parser *priv, struct vkd3d_shader_register *reg)
{
switch (priv->shader_version.type)
{
@@ -1004,7 +971,7 @@ static enum vkd3d_data_type map_data_type(char t)
}
}
-static bool shader_sm4_init(struct vkd3d_sm4_data *sm4, const uint32_t *byte_code, size_t byte_code_size,
+static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t *byte_code, size_t byte_code_size,
const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context)
{
uint32_t version_token, token_count;
@@ -1086,7 +1053,7 @@ static bool shader_sm4_init(struct vkd3d_sm4_data *sm4, const uint32_t *byte_cod
void shader_sm4_free(struct vkd3d_shader_parser *parser)
{
- struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
+ struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
struct vkd3d_shader_src_param_entry *e1, *e2;
list_move_head(&sm4->src_free, &sm4->src);
@@ -1098,7 +1065,7 @@ void shader_sm4_free(struct vkd3d_shader_parser *parser)
vkd3d_free(sm4);
}
-static struct vkd3d_shader_src_param *get_src_param(struct vkd3d_sm4_data *priv)
+static struct vkd3d_shader_src_param *get_src_param(struct vkd3d_shader_sm4_parser *priv)
{
struct vkd3d_shader_src_param_entry *e;
struct list *elem;
@@ -1122,14 +1089,14 @@ static struct vkd3d_shader_src_param *get_src_param(struct vkd3d_sm4_data *priv)
void shader_sm4_read_header(struct vkd3d_shader_parser *parser, struct vkd3d_shader_version *shader_version)
{
- struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
+ struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
parser->ptr = sm4->start;
*shader_version = sm4->shader_version;
}
-static bool shader_sm4_read_reg_idx(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- DWORD addressing, struct vkd3d_shader_register_index *reg_idx)
+static bool shader_sm4_read_reg_idx(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
+ const uint32_t *end, uint32_t addressing, struct vkd3d_shader_register_index *reg_idx)
{
if (addressing & VKD3D_SM4_ADDRESSING_RELATIVE)
{
@@ -1171,9 +1138,8 @@ static bool sm4_register_is_descriptor(enum vkd3d_sm4_register_type register_typ
}
}
-static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- enum vkd3d_data_type data_type, struct vkd3d_shader_register *param,
- enum vkd3d_shader_src_modifier *modifier)
+static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr, const uint32_t *end,
+ enum vkd3d_data_type data_type, struct vkd3d_shader_register *param, enum vkd3d_shader_src_modifier *modifier)
{
enum vkd3d_sm4_register_precision precision;
enum vkd3d_sm4_register_type register_type;
@@ -1396,8 +1362,8 @@ static uint32_t swizzle_from_sm4(uint32_t s)
return vkd3d_shader_create_swizzle(s & 0x3, (s >> 2) & 0x3, (s >> 4) & 0x3, (s >> 6) & 0x3);
}
-static bool shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- enum vkd3d_data_type data_type, struct vkd3d_shader_src_param *src_param)
+static bool shader_sm4_read_src_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
+ const uint32_t *end, enum vkd3d_data_type data_type, struct vkd3d_shader_src_param *src_param)
{
DWORD token;
@@ -1450,8 +1416,8 @@ static bool shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD *
return true;
}
-static bool shader_sm4_read_dst_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
- enum vkd3d_data_type data_type, struct vkd3d_shader_dst_param *dst_param)
+static bool shader_sm4_read_dst_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr,
+ const uint32_t *end, enum vkd3d_data_type data_type, struct vkd3d_shader_dst_param *dst_param)
{
enum vkd3d_shader_src_modifier modifier;
DWORD token;
@@ -1573,7 +1539,7 @@ static void shader_sm4_read_instruction_modifier(DWORD modifier, struct vkd3d_sh
void shader_sm4_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins)
{
- struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
+ struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
const struct vkd3d_sm4_opcode_info *opcode_info;
uint32_t opcode_token, opcode, previous_token;
const uint32_t **ptr = &parser->ptr;
@@ -1693,14 +1659,14 @@ fail:
bool shader_sm4_is_end(struct vkd3d_shader_parser *parser)
{
- struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
+ struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
return parser->ptr == sm4->end;
}
void shader_sm4_reset(struct vkd3d_shader_parser *parser)
{
- struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
+ struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);
parser->ptr = sm4->start;
}
@@ -1709,7 +1675,7 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi
struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser)
{
struct vkd3d_shader_desc *shader_desc;
- struct vkd3d_sm4_data *sm4;
+ struct vkd3d_shader_sm4_parser *sm4;
int ret;
if (!(sm4 = vkd3d_calloc(1, sizeof(*sm4))))
--
2.20.1
1
0
[PATCH vkd3d 1/5] vkd3d-shader/sm4: Store a vkd3d_shader_parser structure in the vkd3d_sm4_data structure.
by Henri Verbeet Oct. 1, 2021
by Henri Verbeet Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
libs/vkd3d-shader/dxbc.c | 103 +++++++++++++++--------
libs/vkd3d-shader/vkd3d_shader_main.c | 70 +++++----------
libs/vkd3d-shader/vkd3d_shader_private.h | 6 +-
3 files changed, 95 insertions(+), 84 deletions(-)
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index 23814a35..da919b1d 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -99,6 +99,7 @@ struct vkd3d_sm4_data
struct vkd3d_shader_immediate_constant_buffer icb;
struct vkd3d_shader_message_context *message_context;
+ struct vkd3d_shader_parser p;
};
struct vkd3d_sm4_opcode_info
@@ -165,6 +166,11 @@ static const enum vkd3d_data_type data_type_table[] =
/* VKD3D_SM4_DATA_UNUSED */ VKD3D_DATA_UNUSED,
};
+static struct vkd3d_sm4_data *vkd3d_sm4_data(struct vkd3d_shader_parser *parser)
+{
+ return CONTAINING_RECORD(parser, struct vkd3d_sm4_data, p);
+}
+
static bool shader_is_sm_5_1(const struct vkd3d_sm4_data *priv)
{
const struct vkd3d_shader_version *version = &priv->shader_version;
@@ -998,17 +1004,16 @@ static enum vkd3d_data_type map_data_type(char t)
}
}
-void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
+static bool shader_sm4_init(struct vkd3d_sm4_data *sm4, const uint32_t *byte_code, size_t byte_code_size,
const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context)
{
- DWORD version_token, token_count;
- struct vkd3d_sm4_data *priv;
+ uint32_t version_token, token_count;
unsigned int i;
if (byte_code_size / sizeof(*byte_code) < 2)
{
WARN("Invalid byte code size %lu.\n", (long)byte_code_size);
- return NULL;
+ return false;
}
version_token = byte_code[0];
@@ -1019,82 +1024,77 @@ void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
if (token_count < 2 || byte_code_size / sizeof(*byte_code) < token_count)
{
WARN("Invalid token count %u.\n", token_count);
- return NULL;
- }
-
- if (!(priv = vkd3d_malloc(sizeof(*priv))))
- {
- ERR("Failed to allocate private data\n");
- return NULL;
+ return false;
}
- priv->start = &byte_code[2];
- priv->end = &byte_code[token_count];
+ sm4->start = &byte_code[2];
+ sm4->end = &byte_code[token_count];
switch (version_token >> 16)
{
case VKD3D_SM4_PS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_PIXEL;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_PIXEL;
break;
case VKD3D_SM4_VS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_VERTEX;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_VERTEX;
break;
case VKD3D_SM4_GS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_GEOMETRY;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_GEOMETRY;
break;
case VKD3D_SM5_HS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_HULL;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_HULL;
break;
case VKD3D_SM5_DS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_DOMAIN;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_DOMAIN;
break;
case VKD3D_SM5_CS:
- priv->shader_version.type = VKD3D_SHADER_TYPE_COMPUTE;
+ sm4->shader_version.type = VKD3D_SHADER_TYPE_COMPUTE;
break;
default:
FIXME("Unrecognised shader type %#x.\n", version_token >> 16);
}
- priv->shader_version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
- priv->shader_version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
+ sm4->shader_version.major = VKD3D_SM4_VERSION_MAJOR(version_token);
+ sm4->shader_version.minor = VKD3D_SM4_VERSION_MINOR(version_token);
- memset(priv->output_map, 0xff, sizeof(priv->output_map));
+ memset(sm4->output_map, 0xff, sizeof(sm4->output_map));
for (i = 0; i < output_signature->element_count; ++i)
{
struct vkd3d_shader_signature_element *e = &output_signature->elements[i];
- if (e->register_index >= ARRAY_SIZE(priv->output_map))
+ if (e->register_index >= ARRAY_SIZE(sm4->output_map))
{
WARN("Invalid output index %u.\n", e->register_index);
continue;
}
- priv->output_map[e->register_index] = e->semantic_index;
+ sm4->output_map[e->register_index] = e->semantic_index;
}
- list_init(&priv->src_free);
- list_init(&priv->src);
+ list_init(&sm4->src_free);
+ list_init(&sm4->src);
- priv->message_context = message_context;
+ sm4->message_context = message_context;
- return priv;
+ return true;
}
void shader_sm4_free(struct vkd3d_shader_parser *parser)
{
+ struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
struct vkd3d_shader_src_param_entry *e1, *e2;
- struct vkd3d_sm4_data *sm4 = parser->data;
list_move_head(&sm4->src_free, &sm4->src);
LIST_FOR_EACH_ENTRY_SAFE(e1, e2, &sm4->src_free, struct vkd3d_shader_src_param_entry, entry)
{
vkd3d_free(e1);
}
+ free_shader_desc(&parser->shader_desc);
vkd3d_free(sm4);
}
@@ -1122,7 +1122,7 @@ static struct vkd3d_shader_src_param *get_src_param(struct vkd3d_sm4_data *priv)
void shader_sm4_read_header(struct vkd3d_shader_parser *parser, struct vkd3d_shader_version *shader_version)
{
- struct vkd3d_sm4_data *sm4 = parser->data;
+ struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
parser->ptr = sm4->start;
*shader_version = sm4->shader_version;
@@ -1573,9 +1573,9 @@ static void shader_sm4_read_instruction_modifier(DWORD modifier, struct vkd3d_sh
void shader_sm4_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins)
{
+ struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
const struct vkd3d_sm4_opcode_info *opcode_info;
uint32_t opcode_token, opcode, previous_token;
- struct vkd3d_sm4_data *sm4 = parser->data;
const uint32_t **ptr = &parser->ptr;
unsigned int i, len;
size_t remaining;
@@ -1693,18 +1693,55 @@ fail:
bool shader_sm4_is_end(struct vkd3d_shader_parser *parser)
{
- struct vkd3d_sm4_data *sm4 = parser->data;
+ struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
return parser->ptr == sm4->end;
}
void shader_sm4_reset(struct vkd3d_shader_parser *parser)
{
- struct vkd3d_sm4_data *sm4 = parser->data;
+ struct vkd3d_sm4_data *sm4 = vkd3d_sm4_data(parser);
parser->ptr = sm4->start;
}
+int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compile_info,
+ struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser)
+{
+ struct vkd3d_shader_desc *shader_desc;
+ struct vkd3d_sm4_data *sm4;
+ int ret;
+
+ if (!(sm4 = vkd3d_calloc(1, sizeof(*sm4))))
+ {
+ ERR("Failed to allocate parser.\n");
+ return VKD3D_ERROR_OUT_OF_MEMORY;
+ }
+
+ shader_desc = &sm4->p.shader_desc;
+ if ((ret = shader_extract_from_dxbc(compile_info->source.code, compile_info->source.size,
+ message_context, compile_info->source_name, shader_desc)) < 0)
+ {
+ WARN("Failed to extract shader, vkd3d result %d.\n", ret);
+ vkd3d_free(sm4);
+ return ret;
+ }
+
+ if (!shader_sm4_init(sm4, shader_desc->byte_code, shader_desc->byte_code_size,
+ &shader_desc->output_signature, message_context))
+ {
+ WARN("Failed to initialise shader parser.\n");
+ free_shader_desc(shader_desc);
+ vkd3d_free(sm4);
+ return VKD3D_ERROR_INVALID_ARGUMENT;
+ }
+
+ shader_sm4_read_header(&sm4->p, &sm4->p.shader_version);
+ *parser = &sm4->p;
+
+ return VKD3D_OK;
+}
+
static bool require_space(size_t offset, size_t count, size_t size, size_t data_size)
{
return !count || (data_size - offset) / count >= size;
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index e38261b4..f253e479 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -372,35 +372,9 @@ void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type,
shader_get_source_type_suffix(source_type), shader->code, shader->size);
}
-static int vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
- const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_message_context *message_context)
-{
- struct vkd3d_shader_desc *shader_desc = &parser->shader_desc;
- int ret;
-
- if ((ret = shader_extract_from_dxbc(compile_info->source.code, compile_info->source.size,
- message_context, compile_info->source_name, shader_desc)) < 0)
- {
- WARN("Failed to extract shader, vkd3d result %d.\n", ret);
- return ret;
- }
-
- if (!(parser->data = shader_sm4_init(shader_desc->byte_code,
- shader_desc->byte_code_size, &shader_desc->output_signature, message_context)))
- {
- WARN("Failed to initialize shader parser.\n");
- free_shader_desc(shader_desc);
- return VKD3D_ERROR_INVALID_ARGUMENT;
- }
-
- shader_sm4_read_header(parser, &parser->shader_version);
- return VKD3D_OK;
-}
-
static void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser)
{
shader_sm4_free(parser);
- free_shader_desc(&parser->shader_desc);
}
static int vkd3d_shader_validate_compile_info(const struct vkd3d_shader_compile_info *compile_info,
@@ -939,7 +913,7 @@ static int scan_dxbc(const struct vkd3d_shader_compile_info *compile_info,
struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info;
struct vkd3d_shader_instruction instruction;
struct vkd3d_shader_scan_context context;
- struct vkd3d_shader_parser parser;
+ struct vkd3d_shader_parser *parser;
int ret;
if ((scan_descriptor_info = vkd3d_find_struct(compile_info->next, SCAN_DESCRIPTOR_INFO)))
@@ -950,7 +924,7 @@ static int scan_dxbc(const struct vkd3d_shader_compile_info *compile_info,
vkd3d_shader_scan_context_init(&context, compile_info, scan_descriptor_info, message_context);
- if ((ret = vkd3d_shader_parser_init(&parser, compile_info, message_context)) < 0)
+ if ((ret = vkd3d_shader_sm4_parser_create(compile_info, message_context, &parser)) < 0)
{
vkd3d_shader_scan_context_cleanup(&context);
return ret;
@@ -958,13 +932,13 @@ static int scan_dxbc(const struct vkd3d_shader_compile_info *compile_info,
if (TRACE_ON())
{
- vkd3d_shader_trace(&parser);
- shader_sm4_reset(&parser);
+ vkd3d_shader_trace(parser);
+ shader_sm4_reset(parser);
}
- while (!shader_sm4_is_end(&parser))
+ while (!shader_sm4_is_end(parser))
{
- shader_sm4_read_instruction(&parser, &instruction);
+ shader_sm4_read_instruction(parser, &instruction);
if (instruction.handler_idx == VKD3DSIH_INVALID)
{
@@ -987,7 +961,7 @@ static int scan_dxbc(const struct vkd3d_shader_compile_info *compile_info,
done:
vkd3d_shader_scan_context_cleanup(&context);
- vkd3d_shader_parser_destroy(&parser);
+ vkd3d_shader_parser_destroy(parser);
return ret;
}
@@ -1037,7 +1011,7 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
struct vkd3d_shader_instruction instruction;
struct vkd3d_shader_compile_info scan_info;
struct vkd3d_dxbc_compiler *spirv_compiler;
- struct vkd3d_shader_parser parser;
+ struct vkd3d_shader_parser *parser;
int ret;
scan_info = *compile_info;
@@ -1048,19 +1022,19 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
if ((ret = scan_dxbc(&scan_info, message_context)) < 0)
return ret;
- if ((ret = vkd3d_shader_parser_init(&parser, compile_info, message_context)) < 0)
+ if ((ret = vkd3d_shader_sm4_parser_create(compile_info, message_context, &parser)) < 0)
{
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
return ret;
}
- vkd3d_shader_dump_shader(compile_info->source_type, parser.shader_version.type, &compile_info->source);
+ vkd3d_shader_dump_shader(compile_info->source_type, parser->shader_version.type, &compile_info->source);
if (compile_info->target_type == VKD3D_SHADER_TARGET_D3D_ASM)
{
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
- ret = vkd3d_dxbc_binary_to_text(&parser, compile_info, out);
- vkd3d_shader_parser_destroy(&parser);
+ ret = vkd3d_dxbc_binary_to_text(parser, compile_info, out);
+ vkd3d_shader_parser_destroy(parser);
return ret;
}
@@ -1068,34 +1042,34 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
{
struct vkd3d_glsl_generator *glsl_generator;
- if (!(glsl_generator = vkd3d_glsl_generator_create(&parser.shader_version, compile_info, message_context)))
+ if (!(glsl_generator = vkd3d_glsl_generator_create(&parser->shader_version, compile_info, message_context)))
{
ERR("Failed to create GLSL generator.\n");
- vkd3d_shader_parser_destroy(&parser);
+ vkd3d_shader_parser_destroy(parser);
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
return VKD3D_ERROR;
}
- ret = vkd3d_glsl_generator_generate(glsl_generator, &parser, out);
+ ret = vkd3d_glsl_generator_generate(glsl_generator, parser, out);
vkd3d_glsl_generator_destroy(glsl_generator);
- vkd3d_shader_parser_destroy(&parser);
+ vkd3d_shader_parser_destroy(parser);
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
return ret;
}
- if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser.shader_version,
- &parser.shader_desc, compile_info, &scan_descriptor_info, message_context)))
+ if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser->shader_version,
+ &parser->shader_desc, compile_info, &scan_descriptor_info, message_context)))
{
ERR("Failed to create DXBC compiler.\n");
- vkd3d_shader_parser_destroy(&parser);
+ vkd3d_shader_parser_destroy(parser);
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
return VKD3D_ERROR;
}
- while (!shader_sm4_is_end(&parser))
+ while (!shader_sm4_is_end(parser))
{
- shader_sm4_read_instruction(&parser, &instruction);
+ shader_sm4_read_instruction(parser, &instruction);
if (instruction.handler_idx == VKD3DSIH_INVALID)
{
@@ -1112,7 +1086,7 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info
ret = vkd3d_dxbc_compiler_generate_spirv(spirv_compiler, compile_info, out);
vkd3d_dxbc_compiler_destroy(spirv_compiler);
- vkd3d_shader_parser_destroy(&parser);
+ vkd3d_shader_parser_destroy(parser);
vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info);
return ret;
}
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 8b3e7624..0ac5ecef 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -891,7 +891,6 @@ struct vkd3d_shader_parser
{
struct vkd3d_shader_desc shader_desc;
struct vkd3d_shader_version shader_version;
- void *data;
const uint32_t *ptr;
};
@@ -901,8 +900,6 @@ const char *shader_get_type_prefix(enum vkd3d_shader_type type);
struct vkd3d_shader_message_context;
-void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
- const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context);
void shader_sm4_free(struct vkd3d_shader_parser *parser);
void shader_sm4_read_header(struct vkd3d_shader_parser *parser, struct vkd3d_shader_version *shader_version);
void shader_sm4_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins);
@@ -1001,6 +998,9 @@ void vkd3d_shader_trace_text_(const char *text, size_t size, const char *functio
#define vkd3d_shader_trace_text(text, size) \
vkd3d_shader_trace_text_(text, size, __FUNCTION__)
+int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compile_info,
+ struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser);
+
int shader_extract_from_dxbc(const void *dxbc, size_t dxbc_length,
struct vkd3d_shader_message_context *message_context, const char *source_name, struct vkd3d_shader_desc *desc);
void free_shader_desc(struct vkd3d_shader_desc *desc);
--
2.20.1
1
0
Oct. 1, 2021
Signed-off-by: Jacek Caban <jacek(a)codeweavers.com>
---
While not very important, the original check was mostly for msvcrt
importlibs. We disable builtins for entire crt modules anyway and other
importlibs should be fine with builtins enabled.
tools/makedep.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
1
0
[v4 PATCH vkd3d 1/2] vkd3d-shader: Don't resize the buffer when there is enough free space.
by Matteo Bruni Oct. 1, 2021
by Matteo Bruni Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com>
---
v2: Handle rc < 0 case, use vkd3d_array_reserve().
v3: Fully make use of vkd3d_array_reserve() (thanks Henri).
v4: Make buffer_size and content_size size_t.
libs/vkd3d-shader/vkd3d_shader_main.c | 10 ++--------
libs/vkd3d-shader/vkd3d_shader_private.h | 3 +--
2 files changed, 3 insertions(+), 10 deletions(-)
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index e38261b4..baf25612 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -41,20 +41,14 @@ static void vkd3d_string_buffer_clear(struct vkd3d_string_buffer *buffer)
static bool vkd3d_string_buffer_resize(struct vkd3d_string_buffer *buffer, int rc)
{
- unsigned int new_buffer_size = buffer->buffer_size * 2;
- char *new_buffer;
+ unsigned int new_buffer_size = rc >= 0 ? buffer->content_size + rc + 1 : max(buffer->buffer_size * 2, 32);
- new_buffer_size = max(new_buffer_size, 32);
- while (rc > 0 && (unsigned int)rc >= new_buffer_size - buffer->content_size)
- new_buffer_size *= 2;
- if (!(new_buffer = vkd3d_realloc(buffer->buffer, new_buffer_size)))
+ if (!vkd3d_array_reserve((void **)&buffer->buffer, &buffer->buffer_size, new_buffer_size, 1))
{
ERR("Failed to grow buffer.\n");
buffer->buffer[buffer->content_size] = '\0';
return false;
}
- buffer->buffer = new_buffer;
- buffer->buffer_size = new_buffer_size;
return true;
}
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 8b3e7624..fa56ba1d 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -912,8 +912,7 @@ void shader_sm4_reset(struct vkd3d_shader_parser *parser);
struct vkd3d_string_buffer
{
char *buffer;
- unsigned int buffer_size;
- unsigned int content_size;
+ size_t buffer_size, content_size;
};
struct vkd3d_string_buffer_cache
--
2.26.3
2
3
[PATCH vkd3d v2 1/6] vkd3d-shader/hlsl: Parse state blocks in variable definitions.
by Zebediah Figura Oct. 1, 2021
by Zebediah Figura Oct. 1, 2021
Oct. 1, 2021
Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com>
---
Makefile.am | 1 +
libs/vkd3d-shader/hlsl.h | 2 +
libs/vkd3d-shader/hlsl.y | 54 ++++++-
tests/hlsl-state-block-syntax.shader_test | 173 ++++++++++++++++++++++
4 files changed, 223 insertions(+), 7 deletions(-)
create mode 100644 tests/hlsl-state-block-syntax.shader_test
diff --git a/Makefile.am b/Makefile.am
index 4a2bf8e18..bc33e0f60 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -74,6 +74,7 @@ vkd3d_shader_tests = \
tests/hlsl-return-implicit-conversion.shader_test \
tests/hlsl-return-void.shader_test \
tests/hlsl-shape.shader_test \
+ tests/hlsl-state-block-syntax.shader_test \
tests/hlsl-static-initializer.shader_test \
tests/hlsl-storage-qualifiers.shader_test \
tests/hlsl-struct-assignment.shader_test \
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 27afeedd4..abc870f4f 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -469,6 +469,8 @@ struct hlsl_ctx
size_t count, size;
} constant_defs;
uint32_t temp_count;
+
+ uint32_t in_state_block : 1;
};
enum hlsl_error_level
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 19745e725..8ad892f9e 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -2558,6 +2558,23 @@ variable_decl:
$$->reg_reservation = $3.reg_reservation;
}
+state:
+ any_identifier '=' expr ';'
+ {
+ vkd3d_free($1);
+ hlsl_free_instr_list($3);
+ }
+
+state_block_start:
+ %empty
+ {
+ ctx->in_state_block = 1;
+ }
+
+state_block:
+ %empty
+ | state_block state
+
variable_def:
variable_decl
| variable_decl '=' complex_initializer
@@ -2565,6 +2582,11 @@ variable_def:
$$ = $1;
$$->initializer = $3;
}
+ | variable_decl '{' state_block_start state_block '}'
+ {
+ $$ = $1;
+ ctx->in_state_block = 0;
+ }
arrays:
%empty
@@ -2861,13 +2883,10 @@ primary_expr:
hlsl_error(ctx, @1, VKD3D_SHADER_ERROR_HLSL_NOT_DEFINED, "Variable \"%s\" is not defined.", $1);
YYABORT;
}
- if ((load = hlsl_new_var_load(ctx, var, @1)))
- {
- if (!($$ = make_list(ctx, &load->node)))
- YYABORT;
- }
- else
- $$ = NULL;
+ if (!(load = hlsl_new_var_load(ctx, var, @1)))
+ YYABORT;
+ if (!($$ = make_list(ctx, &load->node)))
+ YYABORT;
}
| '(' expr ')'
{
@@ -2878,6 +2897,27 @@ primary_expr:
if (!($$ = add_call(ctx, $1, &$3, @1)))
YYABORT;
}
+ | NEW_IDENTIFIER
+ {
+ if (ctx->in_state_block)
+ {
+ struct hlsl_ir_load *load;
+ struct hlsl_ir_var *var;
+
+ if (!(var = hlsl_new_synthetic_var(ctx, "<state-block-expr>",
+ ctx->builtin_types.scalar[HLSL_TYPE_INT], @1)))
+ YYABORT;
+ if (!(load = hlsl_new_var_load(ctx, var, @1)))
+ YYABORT;
+ if (!($$ = make_list(ctx, &load->node)))
+ YYABORT;
+ }
+ else
+ {
+ hlsl_error(ctx, @1, VKD3D_SHADER_ERROR_HLSL_NOT_DEFINED, "Identifier \"%s\" is not declared.\n", $1);
+ YYABORT;
+ }
+ }
postfix_expr:
primary_expr
diff --git a/tests/hlsl-state-block-syntax.shader_test b/tests/hlsl-state-block-syntax.shader_test
new file mode 100644
index 000000000..26853bf40
--- /dev/null
+++ b/tests/hlsl-state-block-syntax.shader_test
@@ -0,0 +1,173 @@
+[pixel shader fail]
+sampler s
+{
+ foo = float;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s = sampler_state
+{
+ foo = float;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s
+{
+ 2 = 3;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s
+{
+ 2;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s
+{
+ foo;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s
+{
+ foo = bar
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s {}
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f {} = 1;
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f = 1 {};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+sampler s = sampler_state;
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f {} : register(c1);
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f
+{
+ foo = (sampler)2;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f
+{
+ foo = (faketype)2;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f
+{
+ foo = (sampler)bar;
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader fail]
+float f
+{
+ foo = bar();
+};
+
+float4 main() : sv_target
+{
+ return float4(0, 0, 0, 0);
+}
+
+[pixel shader]
+float u : register(c1) {};
+float4 main() : sv_target
+{
+ float zero = 0;
+ float a {};
+ float b
+ {
+ foo = bar;
+ foo = bar;
+ foo = (int)2;
+ foo = (int)bar;
+ foo = float4(bar, baz, qux, xyzzy);
+ foo = zero++;
+ };
+ float c {}, d = 1, e;
+ struct {int a;} s {foo = bar;};
+ return float4(0, 1, zero, 1);
+}
+
+[test]
+draw quad
+probe all rgba (0, 1, 0, 1)
--
2.33.0
4
23