- Wine-Devel - list.winehq.org

[PATCH] dwrite: Add partial implementation for IDWriteFontFace5::Equals().
by Nikolay Sivov Aug. 21, 2020

Aug. 21, 2020

Issue with missing method spotted by Brendan Shanks. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- Fixes crash in current CEF. dlls/dwrite/font.c | 17 +++++++++++++++++ dlls/dwrite/tests/font.c | 11 ++++++++++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/dlls/dwrite/font.c b/dlls/dwrite/font.c index 19fe911420f..aa51c744297 100644 --- a/dlls/dwrite/font.c +++ b/dlls/dwrite/font.c @@ -1562,6 +1562,22 @@ static HRESULT WINAPI dwritefontface5_GetFontResource(IDWriteFontFace5 *iface, I return IDWriteFactory7_CreateFontResource(fontface->factory, fontface->files[0], fontface->index, resource); } +static BOOL WINAPI dwritefontface5_Equals(IDWriteFontFace5 *iface, IDWriteFontFace *other) +{ + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface), *other_face; + + TRACE("%p, %p.\n", iface, other); + + if (!(other_face = unsafe_impl_from_IDWriteFontFace(other))) + return FALSE; + + /* TODO: add variations support */ + + return fontface->index == other_face->index && + fontface->simulations == other_face->simulations && + is_same_fontfile(fontface->files[0], other_face->files[0]); +} + static const IDWriteFontFace5Vtbl dwritefontfacevtbl = { dwritefontface_QueryInterface, @@ -1621,6 +1637,7 @@ static const IDWriteFontFace5Vtbl dwritefontfacevtbl = dwritefontface5_GetFontAxisValues, dwritefontface5_HasVariations, dwritefontface5_GetFontResource, + dwritefontface5_Equals, }; static HRESULT WINAPI dwritefontface_reference_QueryInterface(IDWriteFontFaceReference *iface, REFIID riid, void **obj) diff --git a/dlls/dwrite/tests/font.c b/dlls/dwrite/tests/font.c index e1024d0263b..becb1a741f7 100644 --- a/dlls/dwrite/tests/font.c +++ b/dlls/dwrite/tests/font.c @@ -1817,13 +1817,14 @@ static void test_CreateFontFace(void) IDWriteFontCollection *collection; DWRITE_FONT_FILE_TYPE file_type; DWRITE_FONT_FACE_TYPE face_type; + IDWriteFontFace5 *fontface5; IDWriteGdiInterop *interop; IDWriteFont *font, *font2; IDWriteFontFamily *family; IDWriteFactory *factory; IDWriteFontFile *file; + BOOL supported, ret; LOGFONTW logfont; - BOOL supported; UINT32 count; WCHAR *path; HRESULT hr; @@ -1908,6 +1909,14 @@ static void test_CreateFontFace(void) ok(hr == S_OK, "got 0x%08x\n", hr); ok(fontface == fontface2, "got %p, was %p\n", fontface2, fontface); + /* Trivial equality test */ + if (SUCCEEDED(IDWriteFontFace_QueryInterface(fontface, &IID_IDWriteFontFace5, (void **)&fontface5))) + { + ret = IDWriteFontFace5_Equals(fontface5, fontface2); + ok(ret, "Unexpected result %d.\n", ret); + IDWriteFontFace5_Release(fontface5); + } + IDWriteFontFace_Release(fontface); IDWriteFontFace_Release(fontface2); IDWriteFont_Release(font2); -- 2.28.0

1 0

[PATCH] ntdll: Add initial tests for arm64 RtlVirtualUnwind
by Martin Storsjo Aug. 21, 2020

Aug. 21, 2020

This doesn't contain many actual tests yet, but provides the infrastructure for adding more tests and for verifying the finer details of how actual windows handles certain unwinding opcodes. The tests added so far pass both on actual windows and on current wine. Signed-off-by: Martin Storsjo <martin(a)martin.st> --- dlls/ntdll/tests/exception.c | 284 +++++++++++++++++++++++++++++++++++ 1 file changed, 284 insertions(+) diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index b8fedd3fea..d91d5826c7 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -4223,6 +4223,285 @@ static void test_debug_service(DWORD numexc) #elif defined(__aarch64__) +#define UNW_FLAG_NHANDLER 0 +#define UNW_FLAG_EHANDLER 1 +#define UNW_FLAG_UHANDLER 2 + +#define UWOP_TWOBYTES(x) (((x) >> 8) & 0xff), ((x) & 0xff) + +#define UWOP_ALLOC_SMALL(size) (0x00 | (size / 16)) +#define UWOP_SAVE_REGP(reg, offset) UWOP_TWOBYTES((0xC8 << 8) | ((reg - 19) << 6) | (offset/8)) +#define UWOP_NOP 0xE5 +#define UWOP_END 0xE4 + +struct results +{ + int pc_offset; /* pc offset from code start */ + int fp_offset; /* fp offset from stack pointer */ + int handler; /* expect handler to be set? */ + ULONG_PTR pc; /* expected final pc value */ + int frame; /* expected frame return value */ + int frame_offset; /* whether the frame return value is an offset or an absolute value */ + int regs[32][2]; /* expected values for registers */ +}; + +struct unwind_test +{ + const BYTE *function; + size_t function_size; + const BYTE *unwind_info; + size_t unwind_size; + const struct results *results; + unsigned int nb_results; +}; + +enum regs +{ + x0, x1, x2, x3, x4, x5, x6, x7, + x8, x9, x10, x11, x12, x13, x14, x15, + x16, x17, x18, x19, x20, x21, x22, x23, + x24, x25, x26, x27, x28, x29, lr, sp +}; + +static const char * const reg_names[32] = +{ + "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", + "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", + "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", + "x24", "x25", "x26", "x27", "x28", "x29", "lr", "sp" +}; + +#define ORIG_LR 0xCCCCCCCC + +#define UWOP(code,info) (UWOP_##code | ((info) << 4)) + +static void call_virtual_unwind( int testnum, const struct unwind_test *test ) +{ + static const int code_offset = 1024; + static const int unwind_offset = 2048; + void *handler, *data; + CONTEXT context; + RUNTIME_FUNCTION runtime_func; + KNONVOLATILE_CONTEXT_POINTERS ctx_ptr; + UINT i, j, k; + ULONG64 fake_stack[256]; + ULONG64 frame, orig_pc, orig_fp, unset_reg, sp_offset = 0; + static const UINT nb_regs = ARRAY_SIZE(test->results[i].regs); + + memcpy( (char *)code_mem + code_offset, test->function, test->function_size ); + memcpy( (char *)code_mem + unwind_offset, test->unwind_info, test->unwind_size ); + + runtime_func.BeginAddress = code_offset; + if (test->unwind_size) + runtime_func.UnwindData = unwind_offset; + else + memcpy(&runtime_func.UnwindData, test->unwind_info, 4); + + trace( "code: %p stack: %p\n", code_mem, fake_stack ); + + for (i = 0; i < test->nb_results; i++) + { + memset( &ctx_ptr, 0, sizeof(ctx_ptr) ); + memset( &context, 0x55, sizeof(context) ); + memset( &unset_reg, 0x55, sizeof(unset_reg) ); + for (j = 0; j < 256; j++) fake_stack[j] = j * 8; + + context.Sp = (ULONG_PTR)fake_stack; + context.Lr = (ULONG_PTR)ORIG_LR; + context.Fp = (ULONG_PTR)fake_stack + test->results[i].fp_offset; + orig_fp = context.Fp; + orig_pc = (ULONG64)code_mem + code_offset + test->results[i].pc_offset; + + trace( "%u/%u: pc=%p (%02x) fp=%p sp=%p\n", testnum, i, + (void *)orig_pc, *(DWORD *)orig_pc, (void *)orig_fp, (void *)context.Sp ); + + data = (void *)0xdeadbeef; + handler = RtlVirtualUnwind( UNW_FLAG_EHANDLER, (ULONG64)code_mem, orig_pc, + &runtime_func, &context, &data, &frame, &ctx_ptr ); + if (test->results[i].handler > 0) + { + /* Yet untested */ + ok( (char *)handler == (char *)code_mem + 0x200, + "%u/%u: wrong handler %p/%p\n", testnum, i, handler, (char *)code_mem + 0x200 ); + if (handler) ok( *(DWORD *)data == 0x08070605, + "%u/%u: wrong handler data %p\n", testnum, i, data ); + } + else + { + ok( handler == NULL, "%u/%u: handler %p instead of NULL\n", testnum, i, handler ); + } + + ok( context.Pc == test->results[i].pc, "%u/%u: wrong pc %p/%p\n", + testnum, i, (void *)context.Pc, (void*)test->results[i].pc ); + ok( frame == (test->results[i].frame_offset ? (ULONG64)fake_stack : 0) + test->results[i].frame, "%u/%u: wrong frame %p/%p\n", + testnum, i, (void *)frame, (char *)(test->results[i].frame_offset ? fake_stack : NULL) + test->results[i].frame ); + + sp_offset = 0; + for (k = 0; k < nb_regs; k++) + { + if (test->results[i].regs[k][0] == -1) + break; + if (test->results[i].regs[k][0] == sp) { + /* If sp is part of the registers list, treat it as an offset + * between the returned frame pointer and the sp register. */ + sp_offset = test->results[i].regs[k][1]; + break; + } + } + ok( frame - sp_offset == context.Sp, "%u/%u: wrong sp %p/%p\n", + testnum, i, (void *)frame - sp_offset, (void *)context.Sp); + + for (j = 0; j < 31; j++) /* Not including sp here */ + { + for (k = 0; k < nb_regs; k++) + { + if (test->results[i].regs[k][0] == -1) + { + k = nb_regs; + break; + } + if (test->results[i].regs[k][0] == j) break; + } + + if (j >= 19 && j <= 30 && (&ctx_ptr.X19)[j - 19]) + { + ok( k < nb_regs, "%u/%u: register %s should not be set to %llx\n", + testnum, i, reg_names[j], context.X[j] ); + if (k < nb_regs) + ok( context.X[j] == test->results[i].regs[k][1], + "%u/%u: register %s wrong %p/%x\n", + testnum, i, reg_names[j], (void *)context.X[j], test->results[i].regs[k][1] ); + } + else if (k < nb_regs) + { + ok( context.X[j] == test->results[i].regs[k][1], + "%u/%u: register %s wrong %p/%x\n", + testnum, i, reg_names[j], (void *)context.X[j], test->results[i].regs[k][1] ); + } + else + { + ok( k == nb_regs, "%u/%u: register %s should be set\n", testnum, i, reg_names[j] ); + if (j == lr) + ok( context.Lr == ORIG_LR, "%u/%u: register lr wrong %p/unset\n", + testnum, i, (void *)context.Lr ); + else if (j == x29) + ok( context.Fp == orig_fp, "%u/%u: register fp wrong %p/unset\n", + testnum, i, (void *)context.Fp ); + else + ok( context.X[j] == unset_reg, + "%u/%u: register %s wrong %p/unset\n", + testnum, i, reg_names[j], (void *)context.X[j]); + } + } + } +} + +#define DW(dword) ((dword >> 0) & 0xff), ((dword >> 8) & 0xff), ((dword >> 16) & 0xff), ((dword >> 24) & 0xff) + +static void test_virtual_unwind(void) +{ + static const BYTE function_0[] = + { + 0xff, 0x83, 0x00, 0xd1, /* 00: sub sp, sp, #32 */ + 0xf3, 0x53, 0x01, 0xa9, /* 04: stp x19, x20, [sp, #16] */ + 0x1f, 0x20, 0x03, 0xd5, /* 08: nop */ + 0xf3, 0x53, 0x41, 0xa9, /* 0c: ldp x19, x20, [sp, #16] */ + 0xff, 0x83, 0x00, 0x91, /* 10: add sp, sp, #32 */ + 0xc0, 0x03, 0x5f, 0xd6, /* 14: ret */ + }; + + static const DWORD unwind_info_0_header = + (sizeof(function_0)/4) | /* function length */ + (0 << 20) | /* X */ + (0 << 21) | /* E */ + (1 << 22) | /* epilog */ + (2 << 27); /* codes */ + static const DWORD unwind_info_0_epilog0 = + (3 << 0) | /* offset */ + (4 << 22); /* index */ + + static const BYTE unwind_info_0[] = + { + DW(unwind_info_0_header), + DW(unwind_info_0_epilog0), + + UWOP_SAVE_REGP(19, 16), /* stp x19, x20, [sp, #16] */ + UWOP_ALLOC_SMALL(32), /* sub sp, sp, #32 */ + UWOP_END, + + UWOP_SAVE_REGP(19, 16), /* stp x19, x20, [sp, #16] */ + UWOP_ALLOC_SMALL(32), /* sub sp, sp, #32 */ + UWOP_END, + }; + + static const struct results results_0[] = + { + /* offset fp handler pc frame offset registers */ + { 0x00, 0x00, 0, ORIG_LR, 0x000, TRUE, { {-1,-1} }}, + { 0x04, 0x00, 0, ORIG_LR, 0x020, TRUE, { {-1,-1} }}, + { 0x08, 0x00, 0, ORIG_LR, 0x020, TRUE, { {x19,0x10}, {x20,0x18}, {-1,-1} }}, + { 0x0c, 0x00, 0, ORIG_LR, 0x020, TRUE, { {x19,0x10}, {x20,0x18}, {-1,-1} }}, + { 0x10, 0x00, 0, ORIG_LR, 0x020, TRUE, { {-1,-1} }}, + { 0x14, 0x00, 0, ORIG_LR, 0x000, TRUE, { {-1,-1} }}, + }; + + + static const BYTE function_1[] = + { + 0xf3, 0x53, 0xbe, 0xa9, /* 00: stp x19, x20, [sp, #-32]! */ + 0xfe, 0x0b, 0x00, 0xf9, /* 04: str x30, [sp, #16] */ + 0xff, 0x43, 0x00, 0xd1, /* 08: sub sp, sp, #16 */ + 0x1f, 0x20, 0x03, 0xd5, /* 0c: nop */ + 0xff, 0x43, 0x00, 0x91, /* 10: add sp, sp, #16 */ + 0xfe, 0x0b, 0x40, 0xf9, /* 14: ldr x30, [sp, #16] */ + 0xf3, 0x53, 0xc2, 0xa8, /* 18: ldp x19, x20, [sp], #32 */ + 0xc0, 0x03, 0x5f, 0xd6, /* 1c: ret */ + }; + + static const DWORD unwind_info_1_packed = + (1 << 0) | /* Flag */ + (sizeof(function_1)/4 << 2) | /* FunctionLength */ + (0 << 13) | /* RegF */ + (2 << 16) | /* RegI */ + (0 << 20) | /* H */ + (1 << 21) | /* CR */ + (3 << 23); /* FrameSize */ + + static const BYTE unwind_info_1[] = { DW(unwind_info_1_packed) }; + + /* The prologue/epilogue locations are commented out below, as we don't + * handle those cases at the moment. */ + static const struct results results_1[] = + { + /* offset fp handler pc frame offset registers */ +#if 0 + { 0x00, 0x00, 0, ORIG_LR, 0x000, TRUE, { {-1,-1} }}, + { 0x04, 0x00, 0, ORIG_LR, 0x020, TRUE, { {x19,0x00}, {x20,0x08}, {-1,-1} }}, + { 0x08, 0x00, 0, 0x10, 0x020, TRUE, { {x19,0x00}, {x20,0x08}, {lr,0x10}, {-1,-1} }}, +#endif + { 0x0c, 0x00, 0, 0x20, 0x030, TRUE, { {x19,0x10}, {x20,0x18}, {lr,0x20}, {-1,-1} }}, + { 0x10, 0x00, 0, 0x20, 0x030, TRUE, { {x19,0x10}, {x20,0x18}, {lr,0x20}, {-1,-1} }}, +#if 0 + { 0x14, 0x00, 0, 0x10, 0x020, TRUE, { {x19,0x00}, {x20,0x08}, {lr,0x10}, {-1,-1} }}, + { 0x18, 0x00, 0, ORIG_LR, 0x020, TRUE, { {x19,0x00}, {x20,0x08}, {-1,-1} }}, + { 0x1c, 0x00, 0, ORIG_LR, 0x000, TRUE, { {-1,-1} }}, +#endif + }; + + static const struct unwind_test tests[] = + { +#define TEST(func, unwind, unwind_packed, results) \ + { func, sizeof(func), unwind, unwind_packed ? 0 : sizeof(unwind), results, ARRAY_SIZE(results) } + TEST(function_0, unwind_info_0, 0, results_0), + TEST(function_1, unwind_info_1, 1, results_1), +#undef TEST + }; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(tests); i++) + call_virtual_unwind( i, &tests[i] ); +} + static void test_thread_context(void) { CONTEXT context; @@ -5585,6 +5864,11 @@ START_TEST(exception) test_dynamic_unwind(); else skip( "Dynamic unwind functions not found\n" ); + +#elif defined(__aarch64__) + + test_virtual_unwind(); + #endif #if 0 -- 2.17.1

2 1

[PATCH] include: Update ARM64 context flag definitions to match current SDKs
by Martin Storsjo Aug. 21, 2020

Aug. 21, 2020

CONTEXT_FLOATING_POINT should be included in CONTEXT_FULL, and there's a new flag CONTEXT_ARM64_X18 (not available without the arch specific prefix) that only is part of CONTEXT_ALL. Update existing code that tries to set these flags accordingly. Signed-off-by: Martin Storsjo <martin(a)martin.st> --- dlls/ntdll/signal_arm64.c | 2 +- dlls/ntdll/unix/signal_arm64.c | 7 ++++--- include/winnt.h | 5 +++-- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/dlls/ntdll/signal_arm64.c b/dlls/ntdll/signal_arm64.c index c8f6014699..aef17dec32 100644 --- a/dlls/ntdll/signal_arm64.c +++ b/dlls/ntdll/signal_arm64.c @@ -97,7 +97,7 @@ __ASM_STDCALL_FUNC( RtlCaptureContext, 8, "mov x1, sp\n\t" "stp x1, x30, [x0, #0x100]\n\t" /* context->Sp,Pc */ "mov w1, #0x400000\n\t" /* CONTEXT_ARM64 */ - "add w1, w1, #0x3\n\t" /* CONTEXT_FULL */ + "add w1, w1, #0x7\n\t" /* CONTEXT_FULL */ "str w1, [x0]\n\t" /* context->ContextFlags */ "mrs x1, NZCV\n\t" "str w1, [x0, #0x4]\n\t" /* context->Cpsr */ diff --git a/dlls/ntdll/unix/signal_arm64.c b/dlls/ntdll/unix/signal_arm64.c index 52f00323a0..a4454af71e 100644 --- a/dlls/ntdll/unix/signal_arm64.c +++ b/dlls/ntdll/unix/signal_arm64.c @@ -311,7 +311,8 @@ static void save_context( CONTEXT *context, const ucontext_t *sigcontext ) { DWORD i; - context->ContextFlags = CONTEXT_FULL; + context->ContextFlags = (CONTEXT_FULL & ~CONTEXT_FLOATING_POINT) | + CONTEXT_ARM64; context->u.s.Fp = FP_sig(sigcontext); /* Frame pointer */ context->u.s.Lr = LR_sig(sigcontext); /* Link register */ context->Sp = SP_sig(sigcontext); /* Stack pointer */ @@ -664,7 +665,7 @@ __ASM_GLOBAL_FUNC( call_user_apc_dispatcher, "csel x0, x19, x0, lo\n\t" "mov sp, x0\n\t" "mov w2, #0x400000\n\t" /* context.ContextFlags = CONTEXT_FULL */ - "movk w2, #3\n\t" + "movk w2, #7\n\t" "mov x1, x19\n\t" "str w2, [x19]\n\t" "mov x0, #~1\n\t" @@ -1039,7 +1040,7 @@ PCONTEXT DECLSPEC_HIDDEN get_initial_context( LPTHREAD_START_ROUTINE entry, void init_thread_context( ctx, entry, arg, relay ); } pthread_sigmask( SIG_UNBLOCK, &server_block_set, NULL ); - ctx->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT; + ctx->ContextFlags = CONTEXT_FULL; return ctx; } diff --git a/include/winnt.h b/include/winnt.h index e22fd5da49..88b7454ba7 100644 --- a/include/winnt.h +++ b/include/winnt.h @@ -1928,11 +1928,12 @@ NTSYSAPI PVOID WINAPI RtlVirtualUnwind(DWORD,DWORD,DWORD,RUNTIME_FUNCTION*,CONTE #define CONTEXT_INTEGER (CONTEXT_ARM64 | 0x00000002) #define CONTEXT_FLOATING_POINT (CONTEXT_ARM64 | 0x00000004) #define CONTEXT_DEBUG_REGISTERS (CONTEXT_ARM64 | 0x00000008) +#define CONTEXT_ARM64_X18 (CONTEXT_ARM64 | 0x00000010) #define CONTEXT_UNWOUND_TO_CALL 0x20000000 -#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER) -#define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS) +#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT) +#define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_ARM64_X18) #define EXCEPTION_READ_FAULT 0 #define EXCEPTION_WRITE_FAULT 1 -- 2.17.1

1 0

[PATCH] winedump: Fix dumping of rare arm64 unwind opcodes
by Martin Storsjo Aug. 21, 2020

Aug. 21, 2020

Signed-off-by: Martin Storsjo <martin(a)martin.st> --- tools/winedump/pe.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/tools/winedump/pe.c b/tools/winedump/pe.c index 7252a6a61f..f03c523be0 100644 --- a/tools/winedump/pe.c +++ b/tools/winedump/pe.c @@ -1345,18 +1345,22 @@ static void dump_arm64_codes( const BYTE *ptr, unsigned int count ) default:printf( "unknown op\n" ); break; } } - else if (ptr[i] == 0xe9) /* MSFT_OP_TRAP_FRAME */ + else if (ptr[i] == 0xe8) /* MSFT_OP_TRAP_FRAME */ { printf( "MSFT_OP_TRAP_FRAME\n" ); } - else if (ptr[i] == 0xea) /* MSFT_OP_MACHINE_FRAME */ + else if (ptr[i] == 0xe9) /* MSFT_OP_MACHINE_FRAME */ { printf( "MSFT_OP_MACHINE_FRAME\n" ); } - else if (ptr[i] == 0xeb) /* MSFT_OP_CONTEXT */ + else if (ptr[i] == 0xea) /* MSFT_OP_CONTEXT */ { printf( "MSFT_OP_CONTEXT\n" ); } + else if (ptr[i] == 0xec) /* MSFT_OP_CLEAR_UNWOUND_TO_CALL */ + { + printf( "MSFT_OP_CLEAR_UNWOUND_TO_CALL\n" ); + } else printf( "??\n"); } } -- 2.17.1

1 0

[PATCH] po: Update Lithuanian translation
by Aurimas Fišeras Aug. 21, 2020

Aug. 21, 2020

1 0

[PATCH] combase: Move CoGetCurrentProcess().
by Nikolay Sivov Aug. 21, 2020

Aug. 21, 2020

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/combase/Makefile.in | 4 + dlls/combase/combase.c | 16 +++ dlls/combase/combase.spec | 2 +- dlls/combase/combase_private.h | 3 + dlls/{ole32 => combase}/irpcss.idl | 0 dlls/combase/rpc.c | 155 +++++++++++++++++++++++++++++ dlls/ole32/Makefile.in | 1 - dlls/ole32/compobj.c | 16 --- dlls/ole32/compobj_private.h | 2 - dlls/ole32/moniker.c | 44 -------- dlls/ole32/ole32.spec | 2 +- 11 files changed, 180 insertions(+), 65 deletions(-) rename dlls/{ole32 => combase}/irpcss.idl (100%) create mode 100644 dlls/combase/rpc.c diff --git a/dlls/combase/Makefile.in b/dlls/combase/Makefile.in index 09e76e48bbb..331360ecfd2 100644 --- a/dlls/combase/Makefile.in +++ b/dlls/combase/Makefile.in @@ -11,5 +11,9 @@ C_SRCS = \ malloc.c \ marshal.c \ roapi.c \ + rpc.c \ string.c \ usrmarshal.c + +IDL_SRCS = \ + irpcss.idl \ diff --git a/dlls/combase/combase.c b/dlls/combase/combase.c index 8ad95329d08..df97799fe08 100644 --- a/dlls/combase/combase.c +++ b/dlls/combase/combase.c @@ -2233,3 +2233,19 @@ HRESULT WINAPI CoGetCurrentLogicalThreadId(GUID *id) return S_OK; } + +/****************************************************************************** + * CoGetCurrentProcess (combase.@) + */ +DWORD WINAPI CoGetCurrentProcess(void) +{ + struct tlsdata *tlsdata; + + if (FAILED(com_get_tlsdata(&tlsdata))) + return 0; + + if (!tlsdata->thread_seqid) + tlsdata->thread_seqid = rpcss_get_next_seqid(); + + return tlsdata->thread_seqid; +} diff --git a/dlls/combase/combase.spec b/dlls/combase/combase.spec index af83e89d174..a88c5d66fe1 100644 --- a/dlls/combase/combase.spec +++ b/dlls/combase/combase.spec @@ -105,7 +105,7 @@ @ stub CoGetClassVersion @ stdcall CoGetContextToken(ptr) @ stdcall CoGetCurrentLogicalThreadId(ptr) -@ stdcall CoGetCurrentProcess() ole32.CoGetCurrentProcess +@ stdcall CoGetCurrentProcess() @ stdcall CoGetDefaultContext(long ptr ptr) @ stdcall CoGetErrorInfo(long ptr) GetErrorInfo @ stdcall CoGetInstanceFromFile(ptr ptr ptr long long wstr long ptr) diff --git a/dlls/combase/combase_private.h b/dlls/combase/combase_private.h index 28a98fd5803..e910166fff2 100644 --- a/dlls/combase/combase_private.h +++ b/dlls/combase/combase_private.h @@ -88,3 +88,6 @@ static inline struct apartment* com_get_current_apt(void) com_get_tlsdata(&tlsdata); return tlsdata->apt; } + +/* RpcSs interface */ +DWORD rpcss_get_next_seqid(void) DECLSPEC_HIDDEN; diff --git a/dlls/ole32/irpcss.idl b/dlls/combase/irpcss.idl similarity index 100% rename from dlls/ole32/irpcss.idl rename to dlls/combase/irpcss.idl diff --git a/dlls/combase/rpc.c b/dlls/combase/rpc.c new file mode 100644 index 00000000000..2fbccfd740d --- /dev/null +++ b/dlls/combase/rpc.c @@ -0,0 +1,155 @@ +/* + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "winsvc.h" + +#include "wine/debug.h" +#include "wine/exception.h" +#include "wine/heap.h" + +#include "irpcss.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ole); + +void * __RPC_USER MIDL_user_allocate(SIZE_T size) +{ + return heap_alloc(size); +} + +void __RPC_USER MIDL_user_free(void *p) +{ + heap_free(p); +} + +static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr) +{ + return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode); +} + +static BOOL start_rpcss(void) +{ + SERVICE_STATUS_PROCESS status; + SC_HANDLE scm, service; + BOOL ret = FALSE; + + TRACE("\n"); + + if (!(scm = OpenSCManagerW(NULL, NULL, 0))) + { + ERR("Failed to open service manager\n"); + return FALSE; + } + + if (!(service = OpenServiceW(scm, L"RpcSs", SERVICE_START | SERVICE_QUERY_STATUS))) + { + ERR("Failed to open RpcSs service\n"); + CloseServiceHandle( scm ); + return FALSE; + } + + if (StartServiceW(service, 0, NULL) || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING) + { + ULONGLONG start_time = GetTickCount64(); + do + { + DWORD dummy; + + if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(status), &dummy)) + break; + if (status.dwCurrentState == SERVICE_RUNNING) + { + ret = TRUE; + break; + } + if (GetTickCount64() - start_time > 30000) break; + Sleep( 100 ); + + } while (status.dwCurrentState == SERVICE_START_PENDING); + + if (status.dwCurrentState != SERVICE_RUNNING) + WARN("RpcSs failed to start %u\n", status.dwCurrentState); + } + else + ERR("Failed to start RpcSs service\n"); + + CloseServiceHandle(service); + CloseServiceHandle(scm); + return ret; +} + +static RPC_BINDING_HANDLE get_rpc_handle(unsigned short *protseq, unsigned short *endpoint) +{ + RPC_BINDING_HANDLE handle = NULL; + RPC_STATUS status; + RPC_WSTR binding; + + status = RpcStringBindingComposeW(NULL, protseq, NULL, endpoint, NULL, &binding); + if (status == RPC_S_OK) + { + status = RpcBindingFromStringBindingW(binding, &handle); + RpcStringFreeW(&binding); + } + + return handle; +} + +static RPC_BINDING_HANDLE get_irpcss_handle(void) +{ + static RPC_BINDING_HANDLE irpcss_handle; + + if (!irpcss_handle) + { + unsigned short protseq[] = IRPCSS_PROTSEQ; + unsigned short endpoint[] = IRPCSS_ENDPOINT; + + RPC_BINDING_HANDLE new_handle = get_rpc_handle(protseq, endpoint); + if (InterlockedCompareExchangePointer(&irpcss_handle, new_handle, NULL)) + /* another thread beat us to it */ + RpcBindingFree(&new_handle); + } + return irpcss_handle; +} + +DWORD rpcss_get_next_seqid(void) +{ + DWORD id = 0; + HRESULT hr; + + for (;;) + { + __TRY + { + hr = irpcss_get_thread_seq_id(get_irpcss_handle(), &id); + } + __EXCEPT(rpc_filter) + { + hr = HRESULT_FROM_WIN32(GetExceptionCode()); + } + __ENDTRY + if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE)) + { + if (start_rpcss()) + continue; + } + break; + } + + return id; +} diff --git a/dlls/ole32/Makefile.in b/dlls/ole32/Makefile.in index a113c7622b4..1c1e28fa4c5 100644 --- a/dlls/ole32/Makefile.in +++ b/dlls/ole32/Makefile.in @@ -45,7 +45,6 @@ RC_SRCS = ole32res.rc IDL_SRCS = \ dcom.idl \ irot.idl \ - irpcss.idl \ ole32_objidl.idl \ ole32_oleidl.idl \ ole32_unknwn.idl diff --git a/dlls/ole32/compobj.c b/dlls/ole32/compobj.c index 671f60e231a..d45cbcc1734 100644 --- a/dlls/ole32/compobj.c +++ b/dlls/ole32/compobj.c @@ -2898,22 +2898,6 @@ done: return res; } -/****************************************************************************** - * CoGetCurrentProcess [OLE32.@] - */ -DWORD WINAPI CoGetCurrentProcess(void) -{ - struct oletls *info = COM_CurrentInfo(); - - if (!info) - return 0; - - if (!info->thread_seqid) - info->thread_seqid = rpcss_get_next_seqid(); - - return info->thread_seqid; -} - /*********************************************************************** * CoIsOle1Class [OLE32.@] * diff --git a/dlls/ole32/compobj_private.h b/dlls/ole32/compobj_private.h index 8419fd04ffa..003cf767cb4 100644 --- a/dlls/ole32/compobj_private.h +++ b/dlls/ole32/compobj_private.h @@ -353,6 +353,4 @@ static inline HRESULT copy_formatetc(FORMATETC *dst, const FORMATETC *src) extern HRESULT EnumSTATDATA_Construct(IUnknown *holder, ULONG index, DWORD array_len, STATDATA *data, BOOL copy, IEnumSTATDATA **ppenum) DECLSPEC_HIDDEN; -extern DWORD rpcss_get_next_seqid(void) DECLSPEC_HIDDEN; - #endif /* __WINE_OLE_COMPOBJ_H */ diff --git a/dlls/ole32/moniker.c b/dlls/ole32/moniker.c index f82159d9e12..e0cdd865c83 100644 --- a/dlls/ole32/moniker.c +++ b/dlls/ole32/moniker.c @@ -41,7 +41,6 @@ #include "compobj_private.h" #include "moniker.h" #include "irot.h" -#include "irpcss.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); @@ -78,7 +77,6 @@ typedef struct RunningObjectTableImpl static RunningObjectTableImpl* runningObjectTableInstance = NULL; static IrotHandle irot_handle; -static RPC_BINDING_HANDLE irpcss_handle; /* define the EnumMonikerImpl structure */ typedef struct EnumMonikerImpl @@ -135,21 +133,6 @@ static IrotHandle get_irot_handle(void) return irot_handle; } -static RPC_BINDING_HANDLE get_irpcss_handle(void) -{ - if (!irpcss_handle) - { - unsigned short protseq[] = IROT_PROTSEQ; - unsigned short endpoint[] = IROT_ENDPOINT; - - RPC_BINDING_HANDLE new_handle = get_rpc_handle(protseq, endpoint); - if (InterlockedCompareExchangePointer(&irpcss_handle, new_handle, NULL)) - /* another thread beat us to it */ - RpcBindingFree(&new_handle); - } - return irpcss_handle; -} - static BOOL start_rpcss(void) { static const WCHAR rpcssW[] = {'R','p','c','S','s',0}; @@ -200,33 +183,6 @@ static BOOL start_rpcss(void) return ret; } -DWORD rpcss_get_next_seqid(void) -{ - DWORD id = 0; - HRESULT hr; - - for (;;) - { - __TRY - { - hr = irpcss_get_thread_seq_id(get_irpcss_handle(), &id); - } - __EXCEPT(rpc_filter) - { - hr = HRESULT_FROM_WIN32(GetExceptionCode()); - } - __ENDTRY - if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE)) - { - if (start_rpcss()) - continue; - } - break; - } - - return id; -} - static HRESULT create_stream_on_mip_ro(const InterfaceData *mip, IStream **stream) { HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData); diff --git a/dlls/ole32/ole32.spec b/dlls/ole32/ole32.spec index 543126e02bd..2564851c4b5 100644 --- a/dlls/ole32/ole32.spec +++ b/dlls/ole32/ole32.spec @@ -33,7 +33,7 @@ @ stdcall CoGetClassObject(ptr long ptr ptr ptr) @ stdcall CoGetContextToken(ptr) combase.CoGetContextToken @ stdcall CoGetCurrentLogicalThreadId(ptr) combase.CoGetCurrentLogicalThreadId -@ stdcall CoGetCurrentProcess() +@ stdcall CoGetCurrentProcess() combase.CoGetCurrentProcess @ stdcall CoGetDefaultContext(long ptr ptr) combase.CoGetDefaultContext @ stdcall CoGetInstanceFromFile(ptr ptr ptr long long wstr long ptr) combase.CoGetInstanceFromFile @ stdcall CoGetInstanceFromIStorage(ptr ptr ptr long ptr long ptr) combase.CoGetInstanceFromIStorage -- 2.28.0

3 2

[PATCH 0/4] macOS/arm64 support
by Martin Storsjo Aug. 21, 2020

Aug. 21, 2020

Hi, I've tried out building and running wine on macOS on arm64, and gotten it working for small test executables at least. Overall it seems to work, but getting it to work requires dealing with three main issues - some of them that can make it hard to use this with any unmodified windows executable: - The page size on darwin on ARM64 is 16 KB, not 4 KB. For some bits, e.g. ntdll/unix, this is possible to handle, but e.g. if one were to build ntdll as a PE, this PE would need to know that it's supposed to run in a different environment. And this one makes it impossible to run normal executables, unless they've been linked with e.g. -Wl,--section-alignment,0x4000. - Setting -pagezero_size to anything less than 4 GB seems to make macOS refuse to run the executable. So this makes it impossible to map anything into the lower 4 GB of the address space. For now, I've worked it around by moving the address at which user_shared_data is allocated. - Memory mappings can't be writable and executable at the same time. If one mmap()s a page and request it to be both writable and executable, writing to it fails, same if changing protection with mprotect(). This requires changes in a few places, to avoid needlessly(?) allocating things as executable, or map buffers first in readwrite mode, while changing to read-execute after filling them. And a potential fourth one that I haven't really dealt with yet: - Darwin also treats x18 as reserved, just like windows, but IIRC the system can spuriously(?) overwrite the register to zero at some times. I haven't run into this in the context of wine on macOS yet though. Regardless of these issues, I'll start off by sending the patches that are the most clean, that should fix compilation for this target at least. Martin Storsjo (4): winebuild: Use the right arm64 page/pageoff relocation syntax for darwin ntdll: Trust libunwind's returned pc value on arm64 ntdll: Fix the arm64 use of libunwind for macOS ntdll: Implement arm64 sigcontext access for macOS dlls/ntdll/unix/signal_arm64.c | 75 +++++++++++++++++++++++++++++++++- tools/winebuild/build.h | 2 + tools/winebuild/import.c | 34 +++++++-------- tools/winebuild/spec32.c | 4 +- tools/winebuild/utils.c | 32 +++++++++++++++ 5 files changed, 128 insertions(+), 19 deletions(-) -- 2.17.1

4 11

[PATCH] ole32: Use public symbol for maximum moniker comparison data length.
by Nikolay Sivov Aug. 21, 2020

Aug. 21, 2020

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/ole32/moniker.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/dlls/ole32/moniker.c b/dlls/ole32/moniker.c index e0cdd865c83..4421219ac1b 100644 --- a/dlls/ole32/moniker.c +++ b/dlls/ole32/moniker.c @@ -44,11 +44,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(ole); -/* see MSDN docs for IROTData::GetComparisonData, which states what this - * constant is - */ -#define MAX_COMPARISON_DATA 2048 - static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr) { return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode); @@ -245,7 +240,7 @@ static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MonikerComparison hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData); if (SUCCEEDED(hr)) { - ULONG size = MAX_COMPARISON_DATA; + ULONG size = ROT_COMPARE_MAX; *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[size])); if (!*moniker_data) { -- 2.28.0

2 1

[PATCH v2 1/4] windows.gaming.input: Add stub dll.
by Rémi Bernon Aug. 21, 2020

Aug. 21, 2020

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v2: Split the patch, moved IAgileObject to objidl.idl, rename channel to "input", rename dll folder. This DLL is used by Death Stranding to enumerate gamepads on startup. It queries these interfaces using the Ro* api, and tries to iterate over the gamepads through the IVectorView interface. Stubbing everything so that the calls return an empty gamepad list is enough to make the game start, and gamepad input then even works. configure.ac | 1 + dlls/windows.gaming.input.dll/Makefile.in | 7 +++ .../windows.gaming.input.spec | 3 ++ .../windows.gaming.input_main.c | 54 +++++++++++++++++++ 4 files changed, 65 insertions(+) create mode 100644 dlls/windows.gaming.input.dll/Makefile.in create mode 100644 dlls/windows.gaming.input.dll/windows.gaming.input.spec create mode 100644 dlls/windows.gaming.input.dll/windows.gaming.input_main.c diff --git a/configure.ac b/configure.ac index 13adf2da7eb..c092dca9177 100644 --- a/configure.ac +++ b/configure.ac @@ -3835,6 +3835,7 @@ WINE_CONFIG_MAKEFILE(dlls/win32s16.dll16,enable_win16) WINE_CONFIG_MAKEFILE(dlls/win87em.dll16,enable_win16) WINE_CONFIG_MAKEFILE(dlls/winaspi.dll16,enable_win16) WINE_CONFIG_MAKEFILE(dlls/windebug.dll16,enable_win16) +WINE_CONFIG_MAKEFILE(dlls/windows.gaming.input.dll) WINE_CONFIG_MAKEFILE(dlls/windowscodecs) WINE_CONFIG_MAKEFILE(dlls/windowscodecs/tests) WINE_CONFIG_MAKEFILE(dlls/windowscodecsext) diff --git a/dlls/windows.gaming.input.dll/Makefile.in b/dlls/windows.gaming.input.dll/Makefile.in new file mode 100644 index 00000000000..782d81ad346 --- /dev/null +++ b/dlls/windows.gaming.input.dll/Makefile.in @@ -0,0 +1,7 @@ +MODULE = windows.gaming.input.dll +IMPORTS = combase uuid + +EXTRADLLFLAGS = -mno-cygwin + +C_SRCS = \ + windows.gaming.input_main.c diff --git a/dlls/windows.gaming.input.dll/windows.gaming.input.spec b/dlls/windows.gaming.input.dll/windows.gaming.input.spec new file mode 100644 index 00000000000..20a8bfa98ea --- /dev/null +++ b/dlls/windows.gaming.input.dll/windows.gaming.input.spec @@ -0,0 +1,3 @@ +@ stdcall -private DllCanUnloadNow() +@ stdcall -private DllGetActivationFactory(ptr ptr) +@ stdcall -private DllGetClassObject(ptr ptr ptr) diff --git a/dlls/windows.gaming.input.dll/windows.gaming.input_main.c b/dlls/windows.gaming.input.dll/windows.gaming.input_main.c new file mode 100644 index 00000000000..3c12a83e6b2 --- /dev/null +++ b/dlls/windows.gaming.input.dll/windows.gaming.input_main.c @@ -0,0 +1,54 @@ +#include <stdarg.h> + +#define COBJMACROS +#include "windef.h" +#include "winbase.h" +#include "winstring.h" +#include "wine/debug.h" +#include "activation.h" +#include "objbase.h" +#include "initguid.h" + +WINE_DEFAULT_DEBUG_CHANNEL(input); + +static const char *debugstr_hstring(HSTRING hstr) +{ + const WCHAR *str; + UINT32 len; + if (hstr && !((ULONG_PTR)hstr >> 16)) return "(invalid)"; + str = WindowsGetStringRawBuffer(hstr, &len); + return wine_dbgstr_wn(str, len); +} + +BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved) +{ + TRACE("(%p, %u, %p)\n", instance, reason, reserved); + + switch (reason) + { + case DLL_WINE_PREATTACH: + return FALSE; /* prefer native version */ + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(instance); + break; + } + + return TRUE; +} + +HRESULT WINAPI DllCanUnloadNow(void) +{ + return S_FALSE; +} + +HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, LPVOID *object) +{ + FIXME("clsid %s, riid %s, object %p stub!\n", debugstr_guid(clsid), debugstr_guid(riid), object); + return CLASS_E_CLASSNOTAVAILABLE; +} + +HRESULT WINAPI DllGetActivationFactory(HSTRING classid, IActivationFactory **factory) +{ + FIXME("classid %s, factory %p stub!\n", debugstr_hstring(classid), factory); + return E_NOINTERFACE; +} -- 2.28.0

1 3

[PATCH 1/5] ntdll/tests: Add test for xstate in extended context.
by Paul Gofman Aug. 21, 2020

Aug. 21, 2020

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- dlls/ntdll/tests/exception.c | 160 +++++++++++++++++++++++++++++++++++ 1 file changed, 160 insertions(+) diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index 1effffd421f..460f0e9a03e 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -30,6 +30,7 @@ #include "winternl.h" #include "excpt.h" #include "wine/test.h" +#include "intrin.h" static void *code_mem; @@ -43,6 +44,7 @@ static ULONG (WINAPI *pRtlRemoveVectoredExceptionHandler)(PVOID handler); static PVOID (WINAPI *pRtlAddVectoredContinueHandler)(ULONG first, PVECTORED_EXCEPTION_HANDLER func); static ULONG (WINAPI *pRtlRemoveVectoredContinueHandler)(PVOID handler); static void (WINAPI *pRtlSetUnhandledExceptionFilter)(PRTL_EXCEPTION_FILTER filter); +static ULONG64 (WINAPI *pRtlGetEnabledExtendedFeatures)(ULONG64); static NTSTATUS (WINAPI *pNtReadVirtualMemory)(HANDLE, const void*, void*, SIZE_T, SIZE_T*); static NTSTATUS (WINAPI *pNtTerminateProcess)(HANDLE handle, LONG exit_code); static NTSTATUS (WINAPI *pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG); @@ -5458,6 +5460,161 @@ static void test_unload_trace(void) } } +#if defined(__i386__) || defined(__x86_64__) + +static const unsigned int test_extended_context_data[8] = {1, 2, 3, 4, 5, 6, 7, 8}; +static const unsigned test_extended_context_spoil_data1[8] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80}; +static const unsigned test_extended_context_spoil_data2[8] = {0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, 0x85}; + +static BOOL test_extended_context_modified_state; + +static DWORD test_extended_context_handler(EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame, + CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher) +{ + static const ULONG64 expected_compaction_mask = 0x8000000000000004; + CONTEXT_EX *xctx = (CONTEXT_EX *)(context + 1); + unsigned int *context_ymm_data; + DWORD expected_min_offset; + BOOL compaction; + int regs[4]; + XSTATE *xs; + + /* Since we got xstates enabled by OS this cpuid level should be supported. */ + __cpuidex(regs, 0xd, 1); + compaction = regs[0] & 2; + todo_wine ok((context->ContextFlags & (CONTEXT_FULL | CONTEXT_XSTATE)) == (CONTEXT_FULL | CONTEXT_XSTATE), + "Got unexpected ContextFlags %#x.\n", context->ContextFlags); + + if ((context->ContextFlags & (CONTEXT_FULL | CONTEXT_XSTATE)) != (CONTEXT_FULL | CONTEXT_XSTATE)) + goto done; + +#ifdef __x86_64__ + { + /* Unwind contexts do not inherit xstate information. */ + DISPATCHER_CONTEXT *dispatch = (DISPATCHER_CONTEXT *)dispatcher; + + ok(!(dispatch->ContextRecord->ContextFlags & 0x40), "Got unexpected ContextRecord->ContextFlags %#x.\n", + dispatch->ContextRecord->ContextFlags); + } +#endif + + ok(xctx->Legacy.Offset == -(int)(sizeof(CONTEXT)), "Got unexpected Legacy.Offset %d.\n", xctx->Legacy.Offset); + ok(xctx->Legacy.Length == sizeof(CONTEXT), "Got unexpected Legacy.Length %d.\n", xctx->Legacy.Length); + ok(xctx->All.Offset == -(int)sizeof(CONTEXT), "Got unexpected All.Offset %d.\n", xctx->All.Offset); + ok(xctx->All.Length == sizeof(CONTEXT) + xctx->XState.Offset + xctx->XState.Length, + "Got unexpected All.Offset %d.\n", xctx->All.Offset); + expected_min_offset = sizeof(void *) == 8 ? sizeof(CONTEXT_EX) + sizeof(EXCEPTION_RECORD) : sizeof(CONTEXT_EX); + ok(xctx->XState.Offset >= expected_min_offset, + "Got unexpected XState.Offset %d.\n", xctx->XState.Offset); + ok(xctx->XState.Length >= sizeof(XSTATE), "Got unexpected XState.Length %d.\n", xctx->XState.Length); + + xs = (XSTATE *)((char *)xctx + xctx->XState.Offset); + context_ymm_data = (unsigned int *)&xs->YmmContext; + ok(!((ULONG_PTR)xs % 64), "Got unexpected xs %p.\n", xs); + + ok((compaction && (xs->CompactionMask & (expected_compaction_mask | 3)) == expected_compaction_mask) + || (!compaction && !xs->CompactionMask), "Got unexpected CompactionMask %s, compaction %#x.\n", + wine_dbgstr_longlong(xs->CompactionMask), compaction); + + if (test_extended_context_modified_state) + { + ok((xs->Mask & 7) == 4, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + ok(!memcmp(context_ymm_data, test_extended_context_data + 4, sizeof(M128A)), + "Got unexpected context data.\n"); + } + else + { + ok(!xs->Mask, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + /* The save area has garbage in this case, the state should be restored to INIT_STATE + * without using these data. */ + memcpy(context_ymm_data, test_extended_context_spoil_data1 + 4, sizeof(M128A)); + } + +done: +#ifdef __GNUC__ + __asm__ volatile("vmovups %0,%%ymm0" : : "m"(test_extended_context_spoil_data2)); +#endif +#ifdef __x86_64__ + ++context->Rip; +#else + if (*(BYTE *)context->Eip == 0xcc) + ++context->Eip; +#endif + return ExceptionContinueExecution; +} + +static void test_extended_context(void) +{ + static BYTE except_code_set_ymm0[] = + { +#ifdef __x86_64__ + 0x48, +#endif + 0xb8, /* mov imm,%ax */ + 0x00, 0x00, 0x00, 0x00, +#ifdef __x86_64__ + 0x00, 0x00, 0x00, 0x00, +#endif + + 0xc5, 0xfc, 0x10, 0x00, /* vmovups (%ax),%ymm0 */ + 0xcc, /* int3 */ + 0xc5, 0xfc, 0x11, 0x00, /* vmovups %ymm0,(%ax) */ + 0xc3, /* ret */ + }; + static BYTE except_code_reset_ymm_state[] = + { +#ifdef __x86_64__ + 0x48, +#endif + 0xb8, /* mov imm,%ax */ + 0x00, 0x00, 0x00, 0x00, +#ifdef __x86_64__ + 0x00, 0x00, 0x00, 0x00, +#endif + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + + 0xc5, 0xf8, 0x77, /* vzeroupper */ + 0x0f, 0x57, 0xc0, /* xorps %xmm0,%xmm0 */ + 0xcc, /* int3 */ + 0xc5, 0xfc, 0x11, 0x00, /* vmovups %ymm0,(%ax) */ + 0xc3, /* ret */ + }; + unsigned int i, address_offset; + unsigned data[8]; + + address_offset = sizeof(void *) == 8 ? 2 : 1; + *(void **)(except_code_set_ymm0 + address_offset) = data; + *(void **)(except_code_reset_ymm_state + address_offset) = data; + + if (!pRtlGetEnabledExtendedFeatures || !(pRtlGetEnabledExtendedFeatures(~(ULONG64)0) & (1 << XSTATE_AVX))) + { + skip("AVX is not supported.\n"); + return; + } + + memset(data, 0xff, sizeof(data)); + test_extended_context_modified_state = FALSE; + run_exception_test(test_extended_context_handler, NULL, except_code_reset_ymm_state, + ARRAY_SIZE(except_code_reset_ymm_state), PAGE_EXECUTE_READ); + for (i = 0; i < 8; ++i) + { + /* Older Windows version do not reset AVX context to INIT_STATE on x86. */ + todo_wine_if(i >= 4) + ok(!data[i] || broken(i >= 4 && sizeof(void *) == 4 && data[i] == test_extended_context_spoil_data2[i]), + "Got unexpected data %#x, i %u.\n", data[i], i); + } + + memcpy(data, test_extended_context_data, sizeof(data)); + test_extended_context_modified_state = TRUE; + run_exception_test(test_extended_context_handler, NULL, except_code_set_ymm0, + ARRAY_SIZE(except_code_set_ymm0), PAGE_EXECUTE_READ); + + for (i = 0; i < 8; ++i) + todo_wine_if(i >= 4) + ok(data[i] == test_extended_context_data[i], "Got unexpected data %#x, i %u.\n", data[i], i); +} +#endif + START_TEST(exception) { HMODULE hntdll = GetModuleHandleA("ntdll.dll"); @@ -5500,6 +5657,7 @@ START_TEST(exception) X(NtResumeProcess); X(RtlGetUnloadEventTrace); X(RtlGetUnloadEventTraceEx); + X(RtlGetEnabledExtendedFeatures); #undef X pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process"); @@ -5582,6 +5740,7 @@ START_TEST(exception) test_dpe_exceptions(); test_prot_fault(); test_kiuserexceptiondispatcher(); + test_extended_context(); #elif defined(__x86_64__) @@ -5620,6 +5779,7 @@ START_TEST(exception) test_dynamic_unwind(); else skip( "Dynamic unwind functions not found\n" ); + test_extended_context(); #endif test_debugger(); -- 2.26.2

2 9