September 2021 - Wine-devel

[PATCH 1/6] dbghelp/dwarf: downgrade FIXME into WARN for empty range
by Eric Pouech 28 Sep '21

28 Sep '21

it happens to be generated for some inline functions, that we badly support yet Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- dlls/dbghelp/dwarf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 0397ffe90b2..f05186eb9c0 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -1236,7 +1236,7 @@ static BOOL dwarf2_read_range(dwarf2_parse_context_t* ctx, const dwarf2_debug_in if (high > *phigh) *phigh = high; } if (*plow == UMAX || *phigh == 0) {FIXME("no entry found\n"); return FALSE;} - if (*plow == *phigh) {FIXME("entry found, but low=high\n"); return FALSE;} + if (*plow == *phigh) {WARN("entry found, but low=high %lx %lx\n", low, high); return FALSE;} return TRUE; } @@ -2002,7 +2002,7 @@ static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t* subpgm, if (!dwarf2_read_range(subpgm->ctx, di, &low_pc, &high_pc)) { - FIXME("cannot read range\n"); + WARN("cannot read range\n"); return; }

3 7

[PATCH v2 3/9] gdi32: Directly use ntdll in init_font_options.
by Jacek Caban 28 Sep '21

28 Sep '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- v2: Fixed commit message. dlls/gdi32/font.c | 61 +++++++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 26 deletions(-)

3 3

[PATCH vkd3d 4/4] vkd3d-shader/sm4: Skip second-order extended operands.
by Henri Verbeet 28 Sep '21

28 Sep '21

From: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 6afb92c5..23814a35 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1213,6 +1213,12 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr } extended = *(*ptr)++; + if (extended & VKD3D_SM4_EXTENDED_OPERAND) + { + FIXME("Skipping second-order extended operand.\n"); + *ptr += *ptr < end; + } + type = extended & VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK; if (type == VKD3D_SM4_EXTENDED_OPERAND_MODIFIER) { @@ -1254,7 +1260,8 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr param->non_uniform = true; extended &= ~(VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK | VKD3D_SM4_REGISTER_MODIFIER_MASK - | VKD3D_SM4_REGISTER_PRECISION_MASK | VKD3D_SM4_REGISTER_NON_UNIFORM_MASK); + | VKD3D_SM4_REGISTER_PRECISION_MASK | VKD3D_SM4_REGISTER_NON_UNIFORM_MASK + | VKD3D_SM4_EXTENDED_OPERAND); if (extended) FIXME("Skipping unhandled extended operand bits 0x%08x.\n", extended); } -- 2.20.1

1 0

[PATCH vkd3d 3/4] vkd3d-shader/sm4: Parse the "non-uniform" modifier.
by Henri Verbeet 28 Sep '21

28 Sep '21

From: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 6 +++++- libs/vkd3d-shader/sm4.h | 3 +++ libs/vkd3d-shader/trace.c | 9 +++++++++ libs/vkd3d-shader/vkd3d_shader_private.h | 1 + 4 files changed, 18 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index f325d9b7..6afb92c5 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1200,6 +1200,7 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr param->type = register_type_table[register_type]; } param->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; + param->non_uniform = false; param->data_type = data_type; *modifier = VKD3DSPSM_NONE; @@ -1249,8 +1250,11 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr param->precision = register_precision_table[precision]; } + if (extended & VKD3D_SM4_REGISTER_NON_UNIFORM_MASK) + param->non_uniform = true; + extended &= ~(VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK | VKD3D_SM4_REGISTER_MODIFIER_MASK - | VKD3D_SM4_REGISTER_PRECISION_MASK); + | VKD3D_SM4_REGISTER_PRECISION_MASK | VKD3D_SM4_REGISTER_NON_UNIFORM_MASK); if (extended) FIXME("Skipping unhandled extended operand bits 0x%08x.\n", extended); } diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index e811f198..3ac41cb0 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -104,6 +104,9 @@ #define VKD3D_SM4_REGISTER_PRECISION_SHIFT 14 #define VKD3D_SM4_REGISTER_PRECISION_MASK (0x7u << VKD3D_SM4_REGISTER_PRECISION_SHIFT) +#define VKD3D_SM4_REGISTER_NON_UNIFORM_SHIFT 17 +#define VKD3D_SM4_REGISTER_NON_UNIFORM_MASK (0x1u << VKD3D_SM4_REGISTER_NON_UNIFORM_SHIFT) + #define VKD3D_SM4_ADDRESSING_SHIFT2 28 #define VKD3D_SM4_ADDRESSING_MASK2 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT2) diff --git a/libs/vkd3d-shader/trace.c b/libs/vkd3d-shader/trace.c index dba50d2a..45f38d13 100644 --- a/libs/vkd3d-shader/trace.c +++ b/libs/vkd3d-shader/trace.c @@ -1202,6 +1202,13 @@ static void shader_print_precision(struct vkd3d_d3d_asm_compiler *compiler, cons vkd3d_string_buffer_printf(buffer, " {%s%s%s}", compiler->colours.modifier, precision, compiler->colours.reset); } +static void shader_print_non_uniform(struct vkd3d_d3d_asm_compiler *compiler, const struct vkd3d_shader_register *reg) +{ + if (reg->non_uniform) + vkd3d_string_buffer_printf(&compiler->buffer, " {%snonuniform%s}", + compiler->colours.modifier, compiler->colours.reset); +} + static void shader_dump_dst_param(struct vkd3d_d3d_asm_compiler *compiler, const struct vkd3d_shader_dst_param *param, bool is_declaration) { @@ -1230,6 +1237,7 @@ static void shader_dump_dst_param(struct vkd3d_d3d_asm_compiler *compiler, } shader_print_precision(compiler, &param->reg); + shader_print_non_uniform(compiler, &param->reg); } static void shader_dump_src_param(struct vkd3d_d3d_asm_compiler *compiler, @@ -1302,6 +1310,7 @@ static void shader_dump_src_param(struct vkd3d_d3d_asm_compiler *compiler, shader_addline(buffer, "|"); shader_print_precision(compiler, &param->reg); + shader_print_non_uniform(compiler, &param->reg); } static void shader_dump_ins_modifiers(struct vkd3d_d3d_asm_compiler *compiler, diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index b48b901f..8b3e7624 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -633,6 +633,7 @@ struct vkd3d_shader_register { enum vkd3d_shader_register_type type; enum vkd3d_shader_register_precision precision; + bool non_uniform; enum vkd3d_data_type data_type; struct vkd3d_shader_register_index idx[3]; enum vkd3d_immconst_type immconst_type; -- 2.20.1

1 0

[PATCH vkd3d 2/4] vkd3d-shader/sm4: Parse register precision modifiers.
by Henri Verbeet 28 Sep '21

28 Sep '21

From: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 27 ++++++++++++++- libs/vkd3d-shader/sm4.h | 12 +++++++ libs/vkd3d-shader/trace.c | 44 ++++++++++++++++++++++++ libs/vkd3d-shader/vkd3d_shader_private.h | 12 +++++++ 4 files changed, 94 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 0d77f024..f325d9b7 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -925,6 +925,16 @@ static const enum vkd3d_shader_register_type register_type_table[] = /* VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL */ VKD3DSPR_DEPTHOUTLE, }; +static const enum vkd3d_shader_register_precision register_precision_table[] = +{ + /* VKD3D_SM4_REGISTER_PRECISION_DEFAULT */ VKD3D_SHADER_REGISTER_PRECISION_DEFAULT, + /* VKD3D_SM4_REGISTER_PRECISION_MIN_FLOAT_16 */ VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_16, + /* VKD3D_SM4_REGISTER_PRECISION_MIN_FLOAT_10 */ VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_10, + /* UNKNOWN */ VKD3D_SHADER_REGISTER_PRECISION_INVALID, + /* VKD3D_SM4_REGISTER_PRECISION_MIN_INT_16 */ VKD3D_SHADER_REGISTER_PRECISION_MIN_INT_16, + /* VKD3D_SM4_REGISTER_PRECISION_MIN_UINT_16 */ VKD3D_SHADER_REGISTER_PRECISION_MIN_UINT_16, +}; + static const struct vkd3d_sm4_opcode_info *get_opcode_info(enum vkd3d_sm4_opcode opcode) { unsigned int i; @@ -1165,6 +1175,7 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr 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; enum vkd3d_sm4_extended_operand_type type; enum vkd3d_sm4_register_modifier m; @@ -1188,6 +1199,7 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr { param->type = register_type_table[register_type]; } + param->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; param->data_type = data_type; *modifier = VKD3DSPSM_NONE; @@ -1225,7 +1237,20 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr break; } - extended &= ~(VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK | VKD3D_SM4_REGISTER_MODIFIER_MASK); + precision = (extended & VKD3D_SM4_REGISTER_PRECISION_MASK) >> VKD3D_SM4_REGISTER_PRECISION_SHIFT; + if (precision >= ARRAY_SIZE(register_precision_table) + || register_precision_table[precision] == VKD3D_SHADER_REGISTER_PRECISION_INVALID) + { + FIXME("Unhandled register precision %#x.\n", precision); + param->precision = VKD3D_SHADER_REGISTER_PRECISION_INVALID; + } + else + { + param->precision = register_precision_table[precision]; + } + + extended &= ~(VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK | VKD3D_SM4_REGISTER_MODIFIER_MASK + | VKD3D_SM4_REGISTER_PRECISION_MASK); if (extended) FIXME("Skipping unhandled extended operand bits 0x%08x.\n", extended); } diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index d64a9eff..e811f198 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -101,6 +101,9 @@ #define VKD3D_SM4_REGISTER_MODIFIER_SHIFT 6 #define VKD3D_SM4_REGISTER_MODIFIER_MASK (0xffu << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) +#define VKD3D_SM4_REGISTER_PRECISION_SHIFT 14 +#define VKD3D_SM4_REGISTER_PRECISION_MASK (0x7u << VKD3D_SM4_REGISTER_PRECISION_SHIFT) + #define VKD3D_SM4_ADDRESSING_SHIFT2 28 #define VKD3D_SM4_ADDRESSING_MASK2 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT2) @@ -407,6 +410,15 @@ enum vkd3d_sm4_register_modifier VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE = 0x03, }; +enum vkd3d_sm4_register_precision +{ + VKD3D_SM4_REGISTER_PRECISION_DEFAULT = 0x0, + VKD3D_SM4_REGISTER_PRECISION_MIN_FLOAT_16 = 0x1, + VKD3D_SM4_REGISTER_PRECISION_MIN_FLOAT_10 = 0x2, + VKD3D_SM4_REGISTER_PRECISION_MIN_INT_16 = 0x4, + VKD3D_SM4_REGISTER_PRECISION_MIN_UINT_16 = 0x5, +}; + enum vkd3d_sm4_output_primitive_type { VKD3D_SM4_OUTPUT_PT_POINTLIST = 0x1, diff --git a/libs/vkd3d-shader/trace.c b/libs/vkd3d-shader/trace.c index 1dca1ae2..dba50d2a 100644 --- a/libs/vkd3d-shader/trace.c +++ b/libs/vkd3d-shader/trace.c @@ -323,7 +323,9 @@ shader_input_sysval_semantic_names[] = struct vkd3d_d3d_asm_colours { const char *reset; + const char *error; const char *literal; + const char *modifier; const char *opcode; const char *reg; const char *swizzle; @@ -1166,6 +1168,40 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const } } +static void shader_print_precision(struct vkd3d_d3d_asm_compiler *compiler, const struct vkd3d_shader_register *reg) +{ + struct vkd3d_string_buffer *buffer = &compiler->buffer; + const char *precision; + + if (reg->precision == VKD3D_SHADER_REGISTER_PRECISION_DEFAULT) + return; + + switch (reg->precision) + { + case VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_16: + precision = "min16f"; + break; + + case VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_10: + precision = "min2_8f"; + break; + + case VKD3D_SHADER_REGISTER_PRECISION_MIN_INT_16: + precision = "min16i"; + break; + + case VKD3D_SHADER_REGISTER_PRECISION_MIN_UINT_16: + precision = "min16u"; + break; + + default: + vkd3d_string_buffer_printf(buffer, " {%s<unhandled precision %#x>%s}", + compiler->colours.error, reg->precision, compiler->colours.reset); + return; + } + vkd3d_string_buffer_printf(buffer, " {%s%s%s}", compiler->colours.modifier, precision, compiler->colours.reset); +} + static void shader_dump_dst_param(struct vkd3d_d3d_asm_compiler *compiler, const struct vkd3d_shader_dst_param *param, bool is_declaration) { @@ -1192,6 +1228,8 @@ static void shader_dump_dst_param(struct vkd3d_d3d_asm_compiler *compiler, shader_addline(buffer, "%c", write_mask_chars[3]); shader_addline(buffer, "%s", compiler->colours.reset); } + + shader_print_precision(compiler, &param->reg); } static void shader_dump_src_param(struct vkd3d_d3d_asm_compiler *compiler, @@ -1262,6 +1300,8 @@ static void shader_dump_src_param(struct vkd3d_d3d_asm_compiler *compiler, } if (src_modifier == VKD3DSPSM_ABS || src_modifier == VKD3DSPSM_ABSNEG) shader_addline(buffer, "|"); + + shader_print_precision(compiler, &param->reg); } static void shader_dump_ins_modifiers(struct vkd3d_d3d_asm_compiler *compiler, @@ -1786,7 +1826,9 @@ enum vkd3d_result vkd3d_dxbc_binary_to_text(struct vkd3d_shader_parser *parser, static const struct vkd3d_d3d_asm_colours no_colours = { .reset = "", + .error = "", .literal = "", + .modifier = "", .opcode = "", .reg = "", .swizzle = "", @@ -1796,7 +1838,9 @@ enum vkd3d_result vkd3d_dxbc_binary_to_text(struct vkd3d_shader_parser *parser, static const struct vkd3d_d3d_asm_colours colours = { .reset = "\x1b[m", + .error = "\x1b[97;41m", .literal = "\x1b[95m", + .modifier = "\x1b[36m", .opcode = "\x1b[96;1m", .reg = "\x1b[96m", .swizzle = "\x1b[93m", diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index b02315ab..b48b901f 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -441,6 +441,17 @@ enum vkd3d_shader_register_type VKD3DSPR_INVALID = ~0u, }; +enum vkd3d_shader_register_precision +{ + VKD3D_SHADER_REGISTER_PRECISION_DEFAULT, + VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_16, + VKD3D_SHADER_REGISTER_PRECISION_MIN_FLOAT_10, + VKD3D_SHADER_REGISTER_PRECISION_MIN_INT_16, + VKD3D_SHADER_REGISTER_PRECISION_MIN_UINT_16, + + VKD3D_SHADER_REGISTER_PRECISION_INVALID = ~0u, +}; + enum vkd3d_data_type { VKD3D_DATA_FLOAT, @@ -621,6 +632,7 @@ struct vkd3d_shader_register_index struct vkd3d_shader_register { enum vkd3d_shader_register_type type; + enum vkd3d_shader_register_precision precision; enum vkd3d_data_type data_type; struct vkd3d_shader_register_index idx[3]; enum vkd3d_immconst_type immconst_type; -- 2.20.1

1 0

[PATCH vkd3d 1/4] vkd3d-shader/sm4: Parse register modifiers separately from the extended operand type.
by Henri Verbeet 28 Sep '21

28 Sep '21

From: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 59 +++++++++++++++++++++--------------- libs/vkd3d-shader/hlsl_sm4.c | 5 +-- libs/vkd3d-shader/sm4.h | 21 ++++++++++--- 3 files changed, 53 insertions(+), 32 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 86cd0ec0..0d77f024 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1166,7 +1166,9 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr enum vkd3d_shader_src_modifier *modifier) { enum vkd3d_sm4_register_type register_type; - DWORD token, order; + enum vkd3d_sm4_extended_operand_type type; + enum vkd3d_sm4_register_modifier m; + uint32_t token, order, extended; if (*ptr >= end) { @@ -1188,42 +1190,49 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr } param->data_type = data_type; - if (token & VKD3D_SM4_REGISTER_MODIFIER) + *modifier = VKD3DSPSM_NONE; + if (token & VKD3D_SM4_EXTENDED_OPERAND) { - DWORD m; - if (*ptr >= end) { WARN("Invalid ptr %p >= end %p.\n", *ptr, end); return false; } - m = *(*ptr)++; + extended = *(*ptr)++; - switch (m) + type = extended & VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK; + if (type == VKD3D_SM4_EXTENDED_OPERAND_MODIFIER) { - case VKD3D_SM4_REGISTER_MODIFIER_NEGATE: - *modifier = VKD3DSPSM_NEG; - break; + m = (extended & VKD3D_SM4_REGISTER_MODIFIER_MASK) >> VKD3D_SM4_REGISTER_MODIFIER_SHIFT; + switch (m) + { + case VKD3D_SM4_REGISTER_MODIFIER_NEGATE: + *modifier = VKD3DSPSM_NEG; + break; - case VKD3D_SM4_REGISTER_MODIFIER_ABS: - *modifier = VKD3DSPSM_ABS; - break; + case VKD3D_SM4_REGISTER_MODIFIER_ABS: + *modifier = VKD3DSPSM_ABS; + break; - case VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE: - *modifier = VKD3DSPSM_ABSNEG; - break; + case VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE: + *modifier = VKD3DSPSM_ABSNEG; + break; - default: - FIXME("Skipping modifier 0x%08x.\n", m); - /* fall-through */ - case VKD3D_SM4_REGISTER_MODIFIER_NONE: - *modifier = VKD3DSPSM_NONE; - break; + default: + FIXME("Unhandled register modifier %#x.\n", m); + /* fall-through */ + case VKD3D_SM4_REGISTER_MODIFIER_NONE: + break; + } + + extended &= ~(VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK | VKD3D_SM4_REGISTER_MODIFIER_MASK); + if (extended) + FIXME("Skipping unhandled extended operand bits 0x%08x.\n", extended); + } + else if (type) + { + FIXME("Skipping unhandled extended operand token 0x%08x (type %#x).\n", extended, type); } - } - else - { - *modifier = VKD3DSPSM_NONE; } order = (token & VKD3D_SM4_REGISTER_ORDER_MASK) >> VKD3D_SM4_REGISTER_ORDER_SHIFT; diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 500c9f43..49579dd5 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -750,11 +750,12 @@ static void write_sm4_instruction(struct vkd3d_bytecode_buffer *buffer, const st token |= sm4_swizzle_type(instr->srcs[i].reg.type) << VKD3D_SM4_SWIZZLE_TYPE_SHIFT; token |= instr->srcs[i].swizzle << VKD3D_SM4_SWIZZLE_SHIFT; if (instr->srcs[i].reg.mod) - token |= VKD3D_SM4_REGISTER_MODIFIER; + token |= VKD3D_SM4_EXTENDED_OPERAND; put_u32(buffer, token); if (instr->srcs[i].reg.mod) - put_u32(buffer, instr->srcs[i].reg.mod); + put_u32(buffer, (instr->srcs[i].reg.mod << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) + | VKD3D_SM4_EXTENDED_OPERAND_MODIFIER); for (j = 0; j < instr->srcs[i].reg.idx_count; ++j) put_u32(buffer, instr->srcs[i].reg.idx[j]); diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index b4dd1632..d64a9eff 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -94,7 +94,12 @@ #define VKD3D_SM4_OPCODE_MASK 0xff -#define VKD3D_SM4_REGISTER_MODIFIER (0x1u << 31) +#define VKD3D_SM4_EXTENDED_OPERAND (0x1u << 31) + +#define VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK 0x3fu + +#define VKD3D_SM4_REGISTER_MODIFIER_SHIFT 6 +#define VKD3D_SM4_REGISTER_MODIFIER_MASK (0xffu << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) #define VKD3D_SM4_ADDRESSING_SHIFT2 28 #define VKD3D_SM4_ADDRESSING_MASK2 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT2) @@ -388,12 +393,18 @@ enum vkd3d_sm4_register_type VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL = 0x27, }; +enum vkd3d_sm4_extended_operand_type +{ + VKD3D_SM4_EXTENDED_OPERAND_NONE = 0x0, + VKD3D_SM4_EXTENDED_OPERAND_MODIFIER = 0x1, +}; + enum vkd3d_sm4_register_modifier { - VKD3D_SM4_REGISTER_MODIFIER_NONE = 0x01, - VKD3D_SM4_REGISTER_MODIFIER_NEGATE = 0x41, - VKD3D_SM4_REGISTER_MODIFIER_ABS = 0x81, - VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE = 0xc1, + VKD3D_SM4_REGISTER_MODIFIER_NONE = 0x00, + VKD3D_SM4_REGISTER_MODIFIER_NEGATE = 0x01, + VKD3D_SM4_REGISTER_MODIFIER_ABS = 0x02, + VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE = 0x03, }; enum vkd3d_sm4_output_primitive_type -- 2.20.1

1 0

[PATCH vkd3d] vkd3d-shader/hlsl: Fix type comparison for column-major matrices.
by Giovanni Mascellani 28 Sep '21

28 Sep '21

Previously hlsl_types_are_equal considered two matrices of different type if one of those had an explicit column-major modifier while the other didn't have any (in which case the matrix is still considered column-major by default). Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 8a2286c4..30098ea3 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -327,8 +327,8 @@ bool hlsl_types_are_equal(const struct hlsl_type *t1, const struct hlsl_type *t2 return false; if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim) return false; - if ((t1->modifiers & HLSL_MODIFIERS_MAJORITY_MASK) - != (t2->modifiers & HLSL_MODIFIERS_MAJORITY_MASK)) + if ((t1->modifiers & HLSL_MODIFIER_ROW_MAJOR) + != (t2->modifiers & HLSL_MODIFIER_ROW_MAJOR)) return false; if (t1->dimx != t2->dimx) return false; -- 2.33.0

3 3

[PATCH vkd3d 1/2] vkd3d-shader/hlsl: Fix a memory leak.
by Giovanni Mascellani 28 Sep '21

28 Sep '21

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_codegen.c | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 9efc3dad..41ba824d 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -1014,6 +1014,7 @@ static void allocate_temp_registers(struct hlsl_ctx *ctx, struct hlsl_ir_functio struct liveness liveness = {0}; allocate_temp_registers_recurse(ctx, entry_func->body, &liveness); ctx->temp_count = liveness.reg_count; + vkd3d_free(liveness.regs); } static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, unsigned int *counter, bool output) -- 2.33.0

3 5

[PATCH 6/9] gdi32: Introduce user_callbacks.
by Jacek Caban 28 Sep '21

28 Sep '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- This is one more hack to unblock the transition. Ultimately, both relevant parts of user32 and gdi32 will live in win32u, so those will be just internal calls. The plan is to move ntgdi to win32u first (we're fairly close to that with this series, but we still need to make it compatible with proper Unix lib) and then work at moving user32 bits (hopefully this can be done more incrementally). dlls/gdi32/Makefile.in | 3 +- dlls/gdi32/driver.c | 74 ++++++++----------- dlls/gdi32/gdiobj.c | 9 +-- dlls/gdi32/ntgdi_private.h | 3 +- dlls/gdi32/palette.c | 27 ++----- dlls/gdi32/region.c | 11 +-- dlls/gdi32/win32u_private.h | 41 +++++++++++ dlls/gdi32/wrappers.c | 141 ++++++++++++++++++++++++++++++++++++ 8 files changed, 228 insertions(+), 81 deletions(-) create mode 100644 dlls/gdi32/win32u_private.h create mode 100644 dlls/gdi32/wrappers.c

2 2

[PATCH 1/6] ole32/composite: Reimplement Inverse().
by Nikolay Sivov 28 Sep '21

28 Sep '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/ole32/compositemoniker.c | 61 +++++++---------------- dlls/ole32/tests/moniker.c | 92 ++++++++++++++++++++++++++++++----- 2 files changed, 97 insertions(+), 56 deletions(-) diff --git a/dlls/ole32/compositemoniker.c b/dlls/ole32/compositemoniker.c index 40889ae42b2..b2ec02e1150 100644 --- a/dlls/ole32/compositemoniker.c +++ b/dlls/ole32/compositemoniker.c @@ -740,57 +740,32 @@ static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange(IMoniker *iface, return hr; } -/****************************************************************************** - * CompositeMoniker_Inverse - ******************************************************************************/ -static HRESULT WINAPI -CompositeMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk) +static HRESULT WINAPI CompositeMonikerImpl_Inverse(IMoniker *iface, IMoniker **inverse) { - HRESULT res; - IMoniker *tempMk,*antiMk,*rightMostMk,*tempInvMk,*rightMostInvMk; - IEnumMoniker *enumMoniker; - - TRACE("(%p,%p)\n",iface,ppmk); - - if (ppmk==NULL) - return E_POINTER; - - /* This method returns a composite moniker that consists of the inverses of each of the components */ - /* of the original composite, stored in reverse order */ - - *ppmk = NULL; - - res=CreateAntiMoniker(&antiMk); - if (FAILED(res)) - return res; - - res=IMoniker_ComposeWith(iface,antiMk,FALSE,&tempMk); - IMoniker_Release(antiMk); - if (FAILED(res)) - return res; - - if (tempMk==NULL) + CompositeMonikerImpl *moniker = impl_from_IMoniker(iface); + IMoniker *right_inverted, *left_inverted; + HRESULT hr; - return IMoniker_Inverse(iface,ppmk); + TRACE("%p, %p.\n", iface, inverse); - else{ + if (!inverse) + return E_INVALIDARG; - IMoniker_Enum(iface,FALSE,&enumMoniker); - IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); - IEnumMoniker_Release(enumMoniker); + *inverse = NULL; - IMoniker_Inverse(rightMostMk,&rightMostInvMk); - CompositeMonikerImpl_Inverse(tempMk,&tempInvMk); + if (FAILED(hr = IMoniker_Inverse(moniker->right, &right_inverted))) return hr; + if (FAILED(hr = IMoniker_Inverse(moniker->left, &left_inverted))) + { + IMoniker_Release(right_inverted); + return hr; + } - res=CreateGenericComposite(rightMostInvMk,tempInvMk,ppmk); + hr = CreateGenericComposite(right_inverted, left_inverted, inverse); - IMoniker_Release(tempMk); - IMoniker_Release(rightMostMk); - IMoniker_Release(tempInvMk); - IMoniker_Release(rightMostInvMk); + IMoniker_Release(left_inverted); + IMoniker_Release(right_inverted); - return res; - } + return hr; } static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *other, diff --git a/dlls/ole32/tests/moniker.c b/dlls/ole32/tests/moniker.c index 7d88c132d3d..7f0b9ec5841 100644 --- a/dlls/ole32/tests/moniker.c +++ b/dlls/ole32/tests/moniker.c @@ -53,18 +53,21 @@ static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOO #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr) -#define CHECK_EXPECTED_METHOD(method_name) \ -do { \ - ok(*expected_method_list != NULL, "Extra method %s called\n", method_name); \ - if (*expected_method_list) \ - { \ - ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n", \ - *expected_method_list, method_name); \ - expected_method_list++; \ - } \ -} while(0) - static char const * const *expected_method_list; + +#define CHECK_EXPECTED_METHOD(method_name) check_expected_method_(__LINE__, method_name) +static void check_expected_method_(unsigned int line, const char *method_name) +{ + if (!expected_method_list) return; + ok(*expected_method_list != NULL, "Extra method %s called\n", method_name); + if (*expected_method_list) + { + ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n", + *expected_method_list, method_name); + expected_method_list++; + } +} + static const WCHAR wszFileName1[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','1','.','d','o','c',0}; static const WCHAR wszFileName2[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','2','.','d','o','c',0}; @@ -384,6 +387,7 @@ struct test_moniker IOleItemContainer IOleItemContainer_iface; IParseDisplayName IParseDisplayName_iface; LONG refcount; + const char *inverse; BOOL no_IROTData; }; @@ -665,7 +669,7 @@ Moniker_ComposeWith(IMoniker* iface, IMoniker* pmkRight, BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite) { CHECK_EXPECTED_METHOD("Moniker_ComposeWith"); - return E_NOTIMPL; + return MK_E_NEEDGENERIC; } static HRESULT WINAPI @@ -714,8 +718,9 @@ Moniker_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, static HRESULT WINAPI Moniker_Inverse(IMoniker* iface,IMoniker** ppmk) { + struct test_moniker *moniker = impl_from_IMoniker(iface); CHECK_EXPECTED_METHOD("Moniker_Inverse"); - return E_NOTIMPL; + return create_moniker_from_desc(moniker->inverse, ppmk); } static HRESULT WINAPI @@ -933,6 +938,7 @@ static void test_ROT(void) hr = IRunningObjectTable_IsRunning(pROT, &test_moniker->IMoniker_iface); ok_ole_success(hr, IRunningObjectTable_IsRunning); ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list); + expected_method_list = NULL; hr = IRunningObjectTable_Revoke(pROT, dwCookie); ok_ole_success(hr, IRunningObjectTable_Revoke); @@ -2545,6 +2551,7 @@ static void test_item_moniker(void) expected_method_list = methods_isrunning; hr = IMoniker_IsRunning(moniker, bindctx, &container_moniker->IMoniker_iface, moniker2); ok(hr == 0x8beef000, "Unexpected hr %#x.\n", hr); + expected_method_list = NULL; IMoniker_Release(moniker2); @@ -3043,6 +3050,7 @@ static void test_generic_composite_moniker(void) { "CI1I3", "CA1I2", MKSYS_GENERICCOMPOSITE, L"!I1!I2" }, }; IMoniker *moniker, *inverse, *moniker1, *moniker2, *moniker3; + struct test_moniker *m, *m2; IEnumMoniker *enummoniker; IRunningObjectTable *rot; DWORD hash, cookie; @@ -3377,6 +3385,64 @@ todo_wine IMoniker_Release(moniker2); IMoniker_Release(moniker1); + /* Inverse() */ + hr = create_moniker_from_desc("CI1I2", &moniker1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + hr = IMoniker_Inverse(moniker1, NULL); + ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); + hr = IMoniker_Inverse(moniker1, &inverse); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + TEST_MONIKER_TYPE(inverse, MKSYS_GENERICCOMPOSITE); + TEST_DISPLAY_NAME(inverse, L"\\..\\.."); + IMoniker_Release(inverse); + IMoniker_Release(moniker1); + + hr = create_moniker_from_desc("CA1A2", &moniker1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + inverse = (void *)0xdeadbeef; + hr = IMoniker_Inverse(moniker1, &inverse); + ok(hr == MK_E_NOINVERSE, "Unexpected hr %#x.\n", hr); + ok(!inverse, "Unexpected pointer.\n"); + IMoniker_Release(moniker1); + + hr = create_moniker_from_desc("CI1A2", &moniker1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + inverse = (void *)0xdeadbeef; + hr = IMoniker_Inverse(moniker1, &inverse); + ok(hr == MK_E_NOINVERSE, "Unexpected hr %#x.\n", hr); + ok(!inverse, "Unexpected pointer.\n"); + IMoniker_Release(moniker1); + + /* Now with custom moniker to observe inverse order */ + m = create_test_moniker(); + m->inverse = "I5"; + hr = create_moniker_from_desc("I1", &moniker1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + hr = CreateGenericComposite(moniker1, &m->IMoniker_iface, &moniker2); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + TEST_MONIKER_TYPE(moniker2, MKSYS_GENERICCOMPOSITE); + inverse = (void *)0xdeadbeef; + hr = IMoniker_Inverse(moniker2, &inverse); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!inverse, "Unexpected pointer.\n"); + IMoniker_Release(moniker1); + + /* Use custom monikers for both, so they don't invert to anti monikers. */ + m2 = create_test_moniker(); + m2->inverse = "I4"; + + hr = CreateGenericComposite(&m2->IMoniker_iface, &m->IMoniker_iface, &moniker2); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + hr = IMoniker_Inverse(moniker2, &inverse); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + TEST_MONIKER_TYPE(inverse, MKSYS_GENERICCOMPOSITE); + TEST_DISPLAY_NAME(inverse, L"!I5!I4"); + IMoniker_Release(inverse); + IMoniker_Release(moniker2); + + IMoniker_Release(&m->IMoniker_iface); + IMoniker_Release(&m2->IMoniker_iface); + IBindCtx_Release(bindctx); } -- 2.33.0

1 5