wine-commits November 2017

wine-commits@winehq.org

2 participants
436 discussions

Zebediah Figura : regedit: Always start the GUI as 64-bit when on a 64-bit prefix.
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: 25c78b61de4a0beccbb9a6f556a1656c8dac7785 URL: http://source.winehq.org/git/wine.git/?a=commit;h=25c78b61de4a0beccbb9a6f55… Author: Zebediah Figura <z.figura12(a)gmail.com> Date: Tue Oct 31 18:27:21 2017 -0500 regedit: Always start the GUI as 64-bit when on a 64-bit prefix. Same as we do with winecfg. This should help to eliminate some confusion with users who may want to edit keys with WOW64 redirection (e.g. Software\\Wine\\Drives). Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- programs/regedit/main.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/programs/regedit/main.c b/programs/regedit/main.c index 8f82580..460a951 100644 --- a/programs/regedit/main.c +++ b/programs/regedit/main.c @@ -24,10 +24,13 @@ #include <stdlib.h> #include <stdio.h> #include <fcntl.h> +#include "wine/debug.h" #define REGEDIT_DECLARE_FUNCTIONS #include "main.h" +WINE_DEFAULT_DEBUG_CHANNEL(regedit); + WCHAR g_pszDefaultValueName[64]; BOOL ProcessCmdLine(WCHAR *cmdline); @@ -138,11 +141,36 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLi { MSG msg; HACCEL hAccel; + BOOL is_wow64; if (ProcessCmdLine(GetCommandLineW())) { return 0; } + if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64) + { + STARTUPINFOW si; + PROCESS_INFORMATION pi; + WCHAR filename[MAX_PATH]; + void *redir; + DWORD exit_code; + + memset( &si, 0, sizeof(si) ); + si.cb = sizeof(si); + GetModuleFileNameW( 0, filename, MAX_PATH ); + + Wow64DisableWow64FsRedirection( &redir ); + if (CreateProcessW( filename, GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )) + { + WINE_TRACE( "restarting %s\n", wine_dbgstr_w(filename) ); + WaitForSingleObject( pi.hProcess, INFINITE ); + GetExitCodeProcess( pi.hProcess, &exit_code ); + ExitProcess( exit_code ); + } + else WINE_ERR( "failed to restart 64-bit %s, err %d\n", wine_dbgstr_w(filename), GetLastError() ); + Wow64RevertWow64FsRedirection( redir ); + } + /* Initialize global strings */ LoadStringW(hInstance, IDS_APP_TITLE, szTitle, COUNT_OF(szTitle)); LoadStringW(hInstance, IDS_REGISTRY_DEFAULT_VALUE, g_pszDefaultValueName, COUNT_OF(g_pszDefaultValueName));

1 0

Donna Whisnant : oleaut32: Add ARM support to DispCallFunc().
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: 0b393119bb868dba303359ba6cbca2d2447a75d6 URL: http://source.winehq.org/git/wine.git/?a=commit;h=0b393119bb868dba303359ba6… Author: Donna Whisnant <dewhisna(a)dewtronics.com> Date: Sat Oct 28 13:00:32 2017 -0500 oleaut32: Add ARM support to DispCallFunc(). Signed-off-by: Donna Whisnant <dewhisna(a)dewtronics.com> Signed-off-by: André Hentschel <nerv(a)dawncrow.de> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/oleaut32/typelib.c | 206 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 206 insertions(+) diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index ebf6d85..86da3e3 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -6422,6 +6422,41 @@ __ASM_GLOBAL_FUNC( call_method, /* same function but returning floating point */ static double (CDECL * const call_double_method)(void*,int,const DWORD_PTR*) = (void *)call_method; +#elif defined(__arm__) + +extern LONGLONG CDECL call_method( void *func, int nb_stk_args, const DWORD *stk_args, const DWORD *reg_args ); +__ASM_GLOBAL_FUNC( call_method, + /* r0 = *func + * r1 = nb_stk_args + * r2 = *stk_args (pointer to 'nb_stk_args' DWORD values to push on stack) + * r3 = *reg_args (pointer to 8, 64-bit d0-d7 (double) values OR as 16, 32-bit s0-s15 (float) values, followed by 4, 32-bit (DWORD) r0-r3 values) + */ + + "push {fp, lr}\n\t" /* Save frame pointer and return address (stack still aligned to 8 bytes) */ + "mov fp, sp\n\t" /* Save stack pointer as our frame for cleaning the stack on return */ + + "lsls r1, r1, #2\n\t" /* r1 = nb_stk_args * sizeof(DWORD) */ + "beq 1f\n\t" /* Skip allocation if no stack args */ + "add r2, r2, r1\n" /* Calculate ending address of incoming stack data */ + "2:\tldr ip, [r2, #-4]!\n\t" /* Get next value */ + "str ip, [sp, #-4]!\n\t" /* Push it on the stack */ + "subs r1, r1, #4\n\t" /* Decrement count */ + "bgt 2b\n\t" /* Loop till done */ + + "1:\tvldm r3!, {s0-s15}\n\t" /* Load the s0-s15/d0-d7 arguments */ + "mov ip, r0\n\t" /* Save the function call address to ip before we nuke r0 with arguments to pass */ + "ldm r3, {r0-r3}\n\t" /* Load the r0-r3 arguments */ + + "blx ip\n\t" /* Call the target function */ + + "mov sp, fp\n\t" /* Clean the stack using fp */ + "pop {fp, pc}\n\t" /* Restore fp and return */ + ) + +/* same function but returning single/double floating point */ +static float (CDECL * const call_float_method)(void *, int, const DWORD *, const DWORD *) = (void *)call_method; +static double (CDECL * const call_double_method)(void *, int, const DWORD *, const DWORD *) = (void *)call_method; + #endif /* __x86_64__ */ static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt) @@ -6813,6 +6848,177 @@ DispCallFunc( TRACE("retval: %s\n", debugstr_variant(pvargResult)); return S_OK; +#elif defined(__arm__) + int argspos; + void *func; + UINT i; + DWORD *args; + struct { + union { + float s[16]; + double d[8]; + } sd; + DWORD r[4]; + } regs; + int rcount; /* 32-bit register index count */ + int scount; /* single-precision float register index count (will be incremented twice for doubles, plus alignment) */ + + TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", + pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult)); + + if (cc != CC_STDCALL && cc != CC_CDECL) + { + FIXME("unsupported calling convention %d\n",cc); + return E_INVALIDARG; + } + + argspos = 0; + rcount = 0; + scount = 0; + + /* Determine if we need to pass a pointer for the return value as arg 0. If so, do that */ + /* first as it will need to be in the 'r' registers: */ + switch (vtReturn) + { + case VT_DECIMAL: + case VT_VARIANT: + regs.r[rcount++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */ + break; + case VT_HRESULT: + WARN("invalid return type %u\n", vtReturn); + return E_INVALIDARG; + default: /* And all others are in 'r', 's', or 'd' registers or have no return value */ + break; + } + + if (pvInstance) + { + const FARPROC *vtable = *(FARPROC **)pvInstance; + func = vtable[oVft/sizeof(void *)]; + regs.r[rcount++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */ + } + else func = (void *)oVft; + + /* maximum size for an argument is sizeof(VARIANT). Also allow for return pointer and stack alignment. */ + args = heap_alloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 ); + + for (i = 0; i < cActuals; i++) + { + VARIANT *arg = prgpvarg[i]; + DWORD *pdwarg = (DWORD *)(arg); /* a reinterpret_cast of the variant, used for copying structures when they are split between registers and stack */ + int ntemp; /* Used for counting words split between registers and stack */ + + switch (prgvt[i]) + { + case VT_EMPTY: + break; + case VT_R4: /* these must be 4-byte aligned, and put in 's' regs or stack, as they are single-floats */ + if (scount < 16) + regs.sd.s[scount++] = V_R4(arg); + else + args[argspos++] = V_UI4(arg); + break; + case VT_R8: /* these must be 8-byte aligned, and put in 'd' regs or stack, as they are double-floats */ + case VT_DATE: + if (scount < 15) + { + scount += (scount % 2); /* align scount to next whole double */ + regs.sd.d[scount/2] = V_R8(arg); + scount += 2; + } + else + { + scount = 16; /* Make sure we flag that all 's' regs are full */ + argspos += (argspos % 2); /* align argspos to 8-bytes */ + memcpy( &args[argspos], &V_R8(arg), sizeof(V_R8(arg)) ); + argspos += sizeof(V_R8(arg)) / sizeof(DWORD); + } + break; + case VT_I8: /* these must be 8-byte aligned, and put in 'r' regs or stack, as they are long-longs */ + case VT_UI8: + case VT_CY: + if (rcount < 3) + { + rcount += (rcount % 2); /* align rcount to 8-byte register pair */ + memcpy( &regs.r[rcount], &V_UI8(arg), sizeof(V_UI8(arg)) ); + rcount += sizeof(V_UI8(arg)) / sizeof(DWORD); + } + else + { + rcount = 4; /* Make sure we flag that all 'r' regs are full */ + argspos += (argspos % 2); /* align argspos to 8-bytes */ + memcpy( &args[argspos], &V_UI8(arg), sizeof(V_UI8(arg)) ); + argspos += sizeof(V_UI8(arg)) / sizeof(DWORD); + } + break; + case VT_DECIMAL: /* these structures are 8-byte aligned, and put in 'r' regs or stack, can be split between the two */ + case VT_VARIANT: + /* 8-byte align 'r' and/or stack: */ + if (rcount < 3) + rcount += (rcount % 2); + else + { + rcount = 4; + argspos += (argspos % 2); + } + ntemp = sizeof(*arg) / sizeof(DWORD); + while (ntemp > 0) + { + if (rcount < 4) + regs.r[rcount++] = *pdwarg++; + else + args[argspos++] = *pdwarg++; + --ntemp; + } + break; + case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ + if (rcount < 4) + regs.r[rcount++] = V_BOOL(arg); + else + args[argspos++] = V_BOOL(arg); + break; + default: + if (rcount < 4) + regs.r[rcount++] = V_UI4(arg); + else + args[argspos++] = V_UI4(arg); + break; + } + TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); + } + + argspos += (argspos % 2); /* Make sure stack function alignment is 8-byte */ + + TRACE("rcount: %d, scount: %d, argspos: %d\n", rcount, scount, argspos); + + switch (vtReturn) + { + case VT_EMPTY: /* EMPTY = no return value */ + case VT_DECIMAL: /* DECIMAL and VARIANT already have a pointer argument passed (see above) */ + case VT_VARIANT: + call_method( func, argspos, args, (DWORD*)&regs ); + break; + case VT_R4: + V_R4(pvargResult) = call_float_method( func, argspos, args, (DWORD*)&regs ); + break; + case VT_R8: + case VT_DATE: + V_R8(pvargResult) = call_double_method( func, argspos, args, (DWORD*)&regs ); + break; + case VT_I8: + case VT_UI8: + case VT_CY: + V_UI8(pvargResult) = call_method( func, argspos, args, (DWORD*)&regs ); + break; + default: + V_UI4(pvargResult) = call_method( func, argspos, args, (DWORD*)&regs ); + break; + } + heap_free( args ); + if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; + TRACE("retval: %s\n", debugstr_variant(pvargResult)); + return S_OK; + #else FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n", pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));

1 0

Alexandre Julliard : setupapi: Use correct architecture for fake dlls on ARM and ARM64.
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: 35719665d79bc1cc3be19628021a154f563daa51 URL: http://source.winehq.org/git/wine.git/?a=commit;h=35719665d79bc1cc3be196280… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed Nov 1 10:41:51 2017 +0100 setupapi: Use correct architecture for fake dlls on ARM and ARM64. Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/setupapi/fakedll.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/dlls/setupapi/fakedll.c b/dlls/setupapi/fakedll.c index d521b0a..d310cc9 100644 --- a/dlls/setupapi/fakedll.c +++ b/dlls/setupapi/fakedll.c @@ -713,6 +713,10 @@ static BOOL CALLBACK register_manifest( HMODULE module, const WCHAR *type, WCHAR static const char current_arch[] = "x86"; #elif defined __x86_64__ static const char current_arch[] = "amd64"; +#elif defined __arm__ + static const char current_arch[] = "arm"; +#elif defined __aarch64__ + static const char current_arch[] = "arm64"; #else static const char current_arch[] = "none"; #endif

1 0

Alexandre Julliard : configure: Require floating point support on ARM.
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: 05fad4b75171291619381bafe9acfbe71890e72c URL: http://source.winehq.org/git/wine.git/?a=commit;h=05fad4b75171291619381bafe… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed Nov 1 09:52:26 2017 +0100 configure: Require floating point support on ARM. Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- configure | 23 +++++++++++++++++++++++ configure.ac | 5 +++++ 2 files changed, 28 insertions(+) diff --git a/configure b/configure index 00b0087..cb21f2a 100755 --- a/configure +++ b/configure @@ -5265,6 +5265,29 @@ rm -f core conftest.err conftest.$ac_objext \ CFLAGS="$CFLAGS -marm" TARGETFLAGS="-marm" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports floating point" >&5 +$as_echo_n "checking whether $CC supports floating point... " >&6; } + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +asm("vmrs r2,fpscr"); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "You need a target with floating point support to build Wine for ARM." "$LINENO" 5 +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext ;; i[3456789]86*) enable_win16=${enable_win16:-yes} diff --git a/configure.ac b/configure.ac index 3039c94..29f4cd1 100644 --- a/configure.ac +++ b/configure.ac @@ -179,6 +179,11 @@ case $host in AC_MSG_ERROR([You need a target with Thumb support to build Wine for ARM.])]) CFLAGS="$CFLAGS -marm" AC_SUBST(TARGETFLAGS,"-marm") + AC_MSG_CHECKING([whether $CC supports floating point]) + WINE_TRY_ASM_LINK(["vmrs r2,fpscr"],,, + [AC_MSG_RESULT([yes])], + [AC_MSG_RESULT([no]) + AC_MSG_ERROR([You need a target with floating point support to build Wine for ARM.])]) ;; i[[3456789]]86*) enable_win16=${enable_win16:-yes}

1 0

Piotr Caban : wine.inf: Add Windows Messaging Subsystem MAPI registry key.
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: bc865fa41a56dfb54b0ed59c02bf180fa764a4c6 URL: http://source.winehq.org/git/wine.git/?a=commit;h=bc865fa41a56dfb54b0ed59c0… Author: Piotr Caban <piotr(a)codeweavers.com> Date: Tue Oct 31 19:42:53 2017 +0100 wine.inf: Add Windows Messaging Subsystem MAPI registry key. Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- loader/wine.inf.in | 1 + 1 file changed, 1 insertion(+) diff --git a/loader/wine.inf.in b/loader/wine.inf.in index 10e8d0a..d88e4ff 100644 --- a/loader/wine.inf.in +++ b/loader/wine.inf.in @@ -679,6 +679,7 @@ HKLM,Software\Microsoft\SystemCertificates,,16 HKLM,Software\Microsoft\TermServLicensing,,16 HKLM,Software\Microsoft\Transaction Server,,16 HKLM,Software\Microsoft\WBEM,"Installation Directory",2,"%11%\wbem" +HKLM,Software\Microsoft\Windows Messaging Subsystem,"MAPI",2,"1" HKLM,Software\Policies,,16 HKLM,Software\Registered Applications,,16 HKLM,System\CurrentControlSet\Control\hivelist,,16

1 0

Alex Henrie : mountmgr: Map ttyACM devices to COM ports on Linux.
by Alexandre Julliard 01 Nov '17

01 Nov '17

Module: wine Branch: master Commit: 4177068d5a1f30f0ad14f6736815d41656ca141d URL: http://source.winehq.org/git/wine.git/?a=commit;h=4177068d5a1f30f0ad14f6736… Author: Alex Henrie <alexhenrie24(a)gmail.com> Date: Wed Nov 1 01:10:05 2017 +0100 mountmgr: Map ttyACM devices to COM ports on Linux. Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/mountmgr.sys/device.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 20c96d0..1437bfc 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -1085,6 +1085,7 @@ static void create_port_devices( DRIVER_OBJECT *driver ) #ifdef linux "/dev/ttyS%u", "/dev/ttyUSB%u", + "/dev/ttyACM%u", #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) "/dev/cuau%u", #elif defined(__DragonFly__)

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits November 2017