dlls/kernel/wowthunk.c

   1 /*
   2  * Win32 WOW Generic Thunk API
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26
  27 #include "wine/winbase16.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "wownt32.h"
  32 #include "excpt.h"
  33 #include "winreg.h"
  34 #include "winternl.h"
  35 #include "file.h"
  36 #include "task.h"
  37 #include "miscemu.h"
  38 #include "stackframe.h"
  39 #include "kernel_private.h"
  40 #include "wine/exception.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(thunk);
  44 WINE_DECLARE_DEBUG_CHANNEL(relay);
  45
  46 /*
  47  * These are the 16-bit side WOW routines.  They reside in wownt16.h
  48  * in the SDK; since we don't support Win16 source code anyway, I've
  49  * placed them here for compilation with Wine ...
  50  */
  51
  52 DWORD WINAPI GetVDMPointer32W16(SEGPTR,UINT16);
  53
  54 DWORD WINAPI LoadLibraryEx32W16(LPCSTR,DWORD,DWORD);
  55 DWORD WINAPI GetProcAddress32W16(DWORD,LPCSTR);
  56 DWORD WINAPI FreeLibrary32W16(DWORD);
  57
  58 #define CPEX_DEST_STDCALL   0x00000000L
  59 #define CPEX_DEST_CDECL     0x80000000L
  60
  61 /* thunk for 16-bit CreateThread */
  62 struct thread_args
  63 {
  64     FARPROC16 proc;
  65     DWORD     param;
  66 };
  67
  68 static DWORD CALLBACK start_thread16( LPVOID threadArgs )
  69 {
  70     struct thread_args args = *(struct thread_args *)threadArgs;
  71     HeapFree( GetProcessHeap(), 0, threadArgs );
  72     return K32WOWCallback16( (DWORD)args.proc, args.param );
  73 }
  74
  75
  76 #ifdef __i386__
  77
  78 /* symbols exported from relay16.s */
  79 extern DWORD WINAPI wine_call_to_16( FARPROC16 target, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  80 extern void WINAPI wine_call_to_16_regs( CONTEXT86 *context, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  81 extern void Call16_Ret_Start(), Call16_Ret_End();
  82 extern void CallTo16_Ret();
  83 extern void CALL32_CBClient_Ret();
  84 extern void CALL32_CBClientEx_Ret();
  85 extern DWORD CallTo16_DataSelector;
  86 extern SEGPTR CALL32_CBClient_RetAddr;
  87 extern SEGPTR CALL32_CBClientEx_RetAddr;
  88 extern BYTE Call16_Start;
  89 extern BYTE Call16_End;
  90
  91 extern void RELAY16_InitDebugLists(void);
  92
  93 static SEGPTR call16_ret_addr;  /* segptr to CallTo16_Ret routine */
  94
  95 /***********************************************************************
  96  *           WOWTHUNK_Init
  97  */
  98 BOOL WOWTHUNK_Init(void)
  99 {
 100     /* allocate the code selector for CallTo16 routines */
 101     WORD codesel = SELECTOR_AllocBlock( (void *)Call16_Ret_Start,
 102                                         (char *)Call16_Ret_End - (char *)Call16_Ret_Start,
 103                                         WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
 104     if (!codesel) return FALSE;
 105
 106       /* Patch the return addresses for CallTo16 routines */
 107
 108     CallTo16_DataSelector = wine_get_ds();
 109     call16_ret_addr = MAKESEGPTR( codesel, (char*)CallTo16_Ret - (char*)Call16_Ret_Start );
 110     CALL32_CBClient_RetAddr =
 111         MAKESEGPTR( codesel, (char*)CALL32_CBClient_Ret - (char*)Call16_Ret_Start );
 112     CALL32_CBClientEx_RetAddr =
 113         MAKESEGPTR( codesel, (char*)CALL32_CBClientEx_Ret - (char*)Call16_Ret_Start );
 114
 115     if (TRACE_ON(relay)) RELAY16_InitDebugLists();
 116     return TRUE;
 117 }
 118
 119
 120 /*************************************************************
 121  *            fix_selector
 122  *
 123  * Fix a selector load that caused an exception if it's in the
 124  * 16-bit relay code.
 125  */
 126 static BOOL fix_selector( CONTEXT *context )
 127 {
 128     WORD *stack;
 129     BYTE *instr = (BYTE *)context->Eip;
 130
 131     if (instr < &Call16_Start || instr >= &Call16_End) return FALSE;
 132
 133     /* skip prefixes */
 134     while (*instr == 0x66 || *instr == 0x67) instr++;
 135
 136     switch(instr[0])
 137     {
 138     case 0x07: /* pop es */
 139     case 0x17: /* pop ss */
 140     case 0x1f: /* pop ds */
 141         break;
 142     case 0x0f: /* extended instruction */
 143         switch(instr[1])
 144         {
 145         case 0xa1: /* pop fs */
 146         case 0xa9: /* pop gs */
 147             break;
 148         default:
 149             return FALSE;
 150         }
 151         break;
 152     default:
 153         return FALSE;
 154     }
 155     stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 156     TRACE( "fixing up selector %x for pop instruction\n", *stack );
 157     *stack = 0;
 158     return TRUE;
 159 }
 160
 161
 162 /*************************************************************
 163  *            call16_handler
 164  *
 165  * Handler for exceptions occurring in 16-bit code.
 166  */
 167 static DWORD call16_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 168                              CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 169 {
 170     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 171     {
 172         /* unwinding: restore the stack pointer in the TEB, and leave the Win16 mutex */
 173         STACK32FRAME *frame32 = (STACK32FRAME *)((char *)frame - offsetof(STACK32FRAME,frame));
 174         NtCurrentTeb()->cur_stack = frame32->frame16;
 175         _LeaveWin16Lock();
 176     }
 177     else if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
 178              record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
 179     {
 180         if (IS_SELECTOR_SYSTEM(context->SegCs))
 181         {
 182             if (fix_selector( context )) return ExceptionContinueExecution;
 183         }
 184         else
 185         {
 186             SEGPTR gpHandler;
 187             DWORD ret = INSTR_EmulateInstruction( record, context );
 188
 189             if (ret != ExceptionContinueSearch) return ret;
 190
 191             /* check for Win16 __GP handler */
 192             if ((gpHandler = HasGPHandler16( MAKESEGPTR( context->SegCs, context->Eip ) )))
 193             {
 194                 WORD *stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 195                 *--stack = context->SegCs;
 196                 *--stack = context->Eip;
 197
 198                 if (!IS_SELECTOR_32BIT(context->SegSs))
 199                     context->Esp = MAKELONG( LOWORD(context->Esp - 2*sizeof(WORD)),
 200                                              HIWORD(context->Esp) );
 201                 else
 202                     context->Esp -= 2*sizeof(WORD);
 203
 204                 context->SegCs = SELECTOROF( gpHandler );
 205                 context->Eip   = OFFSETOF( gpHandler );
 206                 return ExceptionContinueExecution;
 207             }
 208         }
 209     }
 210     return ExceptionContinueSearch;
 211 }
 212
 213
 214 /*************************************************************
 215  *            vm86_handler
 216  *
 217  * Handler for exceptions occurring in vm86 code.
 218  */
 219 static DWORD vm86_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 220                            CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 221 {
 222     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 223         return ExceptionContinueSearch;
 224
 225     if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
 226         record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
 227     {
 228         return INSTR_EmulateInstruction( record, context );
 229     }
 230
 231     return ExceptionContinueSearch;
 232 }
 233
 234
 235 #else  /* __i386__ */
 236
 237 BOOL WOWTHUNK_Init(void)
 238 {
 239     return TRUE;
 240 }
 241
 242 #endif  /* __i386__ */
 243
 244
 245 /*
 246  *  32-bit WOW routines (in WOW32, but actually forwarded to KERNEL32)
 247  */
 248
 249 /**********************************************************************
 250  *           K32WOWGetDescriptor        (KERNEL32.70)
 251  */
 252 BOOL WINAPI K32WOWGetDescriptor( SEGPTR segptr, LPLDT_ENTRY ldtent )
 253 {
 254     return GetThreadSelectorEntry( GetCurrentThread(),
 255                                    segptr >> 16, ldtent );
 256 }
 257
 258 /**********************************************************************
 259  *           K32WOWGetVDMPointer        (KERNEL32.56)
 260  */
 261 LPVOID WINAPI K32WOWGetVDMPointer( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 262 {
 263     /* FIXME: add size check too */
 264
 265     if ( fProtectedMode )
 266         return MapSL( vp );
 267     else
 268         return DOSMEM_MapRealToLinear( vp );
 269 }
 270
 271 /**********************************************************************
 272  *           K32WOWGetVDMPointerFix     (KERNEL32.68)
 273  */
 274 LPVOID WINAPI K32WOWGetVDMPointerFix( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 275 {
 276     /*
 277      * Hmmm. According to the docu, we should call:
 278      *
 279      *          GlobalFix16( SELECTOROF(vp) );
 280      *
 281      * But this is unnecessary under Wine, as we never move global
 282      * memory segments in linear memory anyway.
 283      *
 284      * (I'm not so sure what we are *supposed* to do if
 285      *  fProtectedMode is TRUE, anyway ...)
 286      */
 287
 288     return K32WOWGetVDMPointer( vp, dwBytes, fProtectedMode );
 289 }
 290
 291 /**********************************************************************
 292  *           K32WOWGetVDMPointerUnfix   (KERNEL32.69)
 293  */
 294 VOID WINAPI K32WOWGetVDMPointerUnfix( DWORD vp )
 295 {
 296     /*
 297      * See above why we don't call:
 298      *
 299      * GlobalUnfix16( SELECTOROF(vp) );
 300      *
 301      */
 302 }
 303
 304 /**********************************************************************
 305  *           K32WOWGlobalAlloc16        (KERNEL32.59)
 306  */
 307 WORD WINAPI K32WOWGlobalAlloc16( WORD wFlags, DWORD cb )
 308 {
 309     return (WORD)GlobalAlloc16( wFlags, cb );
 310 }
 311
 312 /**********************************************************************
 313  *           K32WOWGlobalFree16         (KERNEL32.62)
 314  */
 315 WORD WINAPI K32WOWGlobalFree16( WORD hMem )
 316 {
 317     return (WORD)GlobalFree16( (HGLOBAL16)hMem );
 318 }
 319
 320 /**********************************************************************
 321  *           K32WOWGlobalUnlock16       (KERNEL32.61)
 322  */
 323 BOOL WINAPI K32WOWGlobalUnlock16( WORD hMem )
 324 {
 325     return (BOOL)GlobalUnlock16( (HGLOBAL16)hMem );
 326 }
 327
 328 /**********************************************************************
 329  *           K32WOWGlobalAllocLock16    (KERNEL32.63)
 330  */
 331 DWORD WINAPI K32WOWGlobalAllocLock16( WORD wFlags, DWORD cb, WORD *phMem )
 332 {
 333     WORD hMem = K32WOWGlobalAlloc16( wFlags, cb );
 334     if (phMem) *phMem = hMem;
 335
 336     return K32WOWGlobalLock16( hMem );
 337 }
 338
 339 /**********************************************************************
 340  *           K32WOWGlobalLockSize16     (KERNEL32.65)
 341  */
 342 DWORD WINAPI K32WOWGlobalLockSize16( WORD hMem, PDWORD pcb )
 343 {
 344     if ( pcb )
 345         *pcb = GlobalSize16( (HGLOBAL16)hMem );
 346
 347     return K32WOWGlobalLock16( hMem );
 348 }
 349
 350 /**********************************************************************
 351  *           K32WOWGlobalUnlockFree16   (KERNEL32.64)
 352  */
 353 WORD WINAPI K32WOWGlobalUnlockFree16( DWORD vpMem )
 354 {
 355     if ( !K32WOWGlobalUnlock16( HIWORD(vpMem) ) )
 356         return FALSE;
 357
 358     return K32WOWGlobalFree16( HIWORD(vpMem) );
 359 }
 360
 361
 362 /**********************************************************************
 363  *           K32WOWYield16              (KERNEL32.66)
 364  */
 365 VOID WINAPI K32WOWYield16( void )
 366 {
 367     /*
 368      * This does the right thing for both Win16 and Win32 tasks.
 369      * More or less, at least :-/
 370      */
 371     Yield16();
 372 }
 373
 374 /**********************************************************************
 375  *           K32WOWDirectedYield16       (KERNEL32.67)
 376  */
 377 VOID WINAPI K32WOWDirectedYield16( WORD htask16 )
 378 {
 379     /*
 380      * Argh.  Our scheduler doesn't like DirectedYield by Win32
 381      * tasks at all.  So we do hope that this routine is indeed
 382      * only ever called by Win16 tasks that have thunked up ...
 383      */
 384     DirectedYield16( (HTASK16)htask16 );
 385 }
 386
 387
 388 /***********************************************************************
 389  *           K32WOWHandle32              (KERNEL32.57)
 390  */
 391 HANDLE WINAPI K32WOWHandle32( WORD handle, WOW_HANDLE_TYPE type )
 392 {
 393     switch ( type )
 394     {
 395     case WOW_TYPE_HWND:
 396     case WOW_TYPE_HMENU:
 397     case WOW_TYPE_HDWP:
 398     case WOW_TYPE_HDROP:
 399     case WOW_TYPE_HDC:
 400     case WOW_TYPE_HFONT:
 401     case WOW_TYPE_HRGN:
 402     case WOW_TYPE_HBITMAP:
 403     case WOW_TYPE_HBRUSH:
 404     case WOW_TYPE_HPALETTE:
 405     case WOW_TYPE_HPEN:
 406     case WOW_TYPE_HACCEL:
 407         return (HANDLE)(ULONG_PTR)handle;
 408
 409     case WOW_TYPE_HMETAFILE:
 410         FIXME( "conversion of metafile handles not supported yet\n" );
 411         return (HANDLE)(ULONG_PTR)handle;
 412
 413     case WOW_TYPE_HTASK:
 414         return ((TDB *)GlobalLock16(handle))->teb->ClientId.UniqueThread;
 415
 416     case WOW_TYPE_FULLHWND:
 417         FIXME( "conversion of full window handles not supported yet\n" );
 418         return (HANDLE)(ULONG_PTR)handle;
 419
 420     default:
 421         ERR( "handle 0x%04x of unknown type %d\n", handle, type );
 422         return (HANDLE)(ULONG_PTR)handle;
 423     }
 424 }
 425
 426 /***********************************************************************
 427  *           K32WOWHandle16              (KERNEL32.58)
 428  */
 429 WORD WINAPI K32WOWHandle16( HANDLE handle, WOW_HANDLE_TYPE type )
 430 {
 431     switch ( type )
 432     {
 433     case WOW_TYPE_HWND:
 434     case WOW_TYPE_HMENU:
 435     case WOW_TYPE_HDWP:
 436     case WOW_TYPE_HDROP:
 437     case WOW_TYPE_HDC:
 438     case WOW_TYPE_HFONT:
 439     case WOW_TYPE_HRGN:
 440     case WOW_TYPE_HBITMAP:
 441     case WOW_TYPE_HBRUSH:
 442     case WOW_TYPE_HPALETTE:
 443     case WOW_TYPE_HPEN:
 444     case WOW_TYPE_HACCEL:
 445     case WOW_TYPE_FULLHWND:
 446         if ( HIWORD(handle ) )
 447                 ERR( "handle %p of type %d has non-zero HIWORD\n", handle, type );
 448         return LOWORD(handle);
 449
 450     case WOW_TYPE_HMETAFILE:
 451         FIXME( "conversion of metafile handles not supported yet\n" );
 452         return LOWORD(handle);
 453
 454     case WOW_TYPE_HTASK:
 455         return TASK_GetTaskFromThread( (DWORD)handle );
 456
 457     default:
 458         ERR( "handle %p of unknown type %d\n", handle, type );
 459         return LOWORD(handle);
 460     }
 461 }
 462
 463 /**********************************************************************
 464  *           K32WOWCallback16Ex         (KERNEL32.55)
 465  */
 466 BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
 467                                 DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode )
 468 {
 469 #ifdef __i386__
 470     /*
 471      * Arguments must be prepared in the correct order by the caller
 472      * (both for PASCAL and CDECL calling convention), so we simply
 473      * copy them to the 16-bit stack ...
 474      */
 475     WORD *stack = (WORD *)CURRENT_STACK16 - cbArgs / sizeof(WORD);
 476
 477     memcpy( stack, pArgs, cbArgs );
 478
 479     if (dwFlags & (WCB16_REGS|WCB16_REGS_LONG))
 480     {
 481         CONTEXT *context = (CONTEXT *)pdwRetCode;
 482
 483         if (TRACE_ON(relay))
 484         {
 485             DWORD count = cbArgs / sizeof(WORD);
 486
 487             DPRINTF("%04lx:CallTo16(func=%04lx:%04x,ds=%04lx",
 488                     GetCurrentThreadId(),
 489                     context->SegCs, LOWORD(context->Eip), context->SegDs );
 490             while (count) DPRINTF( ",%04x", stack[--count] );
 491             DPRINTF(") ss:sp=%04x:%04x",
 492                     SELECTOROF(NtCurrentTeb()->cur_stack), OFFSETOF(NtCurrentTeb()->cur_stack) );
 493             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x bp=%04x es=%04x fs=%04x\n",
 494                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 495                     (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
 496                     (WORD)context->Ebp, (WORD)context->SegEs, (WORD)context->SegFs );
 497             SYSLEVEL_CheckNotLevel( 2 );
 498         }
 499
 500         if (ISV86(context))
 501         {
 502             EXCEPTION_REGISTRATION_RECORD frame;
 503             frame.Handler = vm86_handler;
 504             __wine_push_frame( &frame );
 505             __wine_enter_vm86( context );
 506             __wine_pop_frame( &frame );
 507         }
 508         else
 509         {
 510             /* push return address */
 511             if (dwFlags & WCB16_REGS_LONG)
 512             {
 513                 *((DWORD *)stack - 1) = HIWORD(call16_ret_addr);
 514                 *((DWORD *)stack - 2) = LOWORD(call16_ret_addr);
 515                 cbArgs += 2 * sizeof(DWORD);
 516             }
 517             else
 518             {
 519                 *((SEGPTR *)stack - 1) = call16_ret_addr;
 520                 cbArgs += sizeof(SEGPTR);
 521             }
 522
 523             _EnterWin16Lock();
 524             wine_call_to_16_regs( context, cbArgs, call16_handler );
 525             _LeaveWin16Lock();
 526         }
 527
 528         if (TRACE_ON(relay))
 529         {
 530             DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x ",
 531                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->cur_stack),
 532                     OFFSETOF(NtCurrentTeb()->cur_stack));
 533             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n",
 534                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 535                     (WORD)context->Edx, (WORD)context->Ebp, (WORD)context->Esp );
 536             SYSLEVEL_CheckNotLevel( 2 );
 537         }
 538     }
 539     else
 540     {
 541         DWORD ret;
 542
 543         if (TRACE_ON(relay))
 544         {
 545             DWORD count = cbArgs / sizeof(WORD);
 546
 547             DPRINTF("%04lx:CallTo16(func=%04x:%04x,ds=%04x",
 548                     GetCurrentThreadId(), HIWORD(vpfn16), LOWORD(vpfn16),
 549                     SELECTOROF(NtCurrentTeb()->cur_stack) );
 550             while (count) DPRINTF( ",%04x", stack[--count] );
 551             DPRINTF(") ss:sp=%04x:%04x\n",
 552                     SELECTOROF(NtCurrentTeb()->cur_stack), OFFSETOF(NtCurrentTeb()->cur_stack) );
 553             SYSLEVEL_CheckNotLevel( 2 );
 554         }
 555
 556         /* push return address */
 557         *((SEGPTR *)stack - 1) = call16_ret_addr;
 558         cbArgs += sizeof(SEGPTR);
 559
 560         /*
 561          * Actually, we should take care whether the called routine cleans up
 562          * its stack or not.  Fortunately, our wine_call_to_16 core doesn't rely on
 563          * the callee to do so; after the routine has returned, the 16-bit
 564          * stack pointer is always reset to the position it had before.
 565          */
 566         _EnterWin16Lock();
 567         ret = wine_call_to_16( (FARPROC16)vpfn16, cbArgs, call16_handler );
 568         if (pdwRetCode) *pdwRetCode = ret;
 569         _LeaveWin16Lock();
 570
 571         if (TRACE_ON(relay))
 572         {
 573             DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x retval=%08lx\n",
 574                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->cur_stack),
 575                     OFFSETOF(NtCurrentTeb()->cur_stack), ret);
 576             SYSLEVEL_CheckNotLevel( 2 );
 577         }
 578     }
 579 #else
 580     assert(0);  /* cannot call to 16-bit on non-Intel architectures */
 581 #endif  /* __i386__ */
 582
 583     return TRUE;  /* success */
 584 }
 585
 586 /**********************************************************************
 587  *           K32WOWCallback16            (KERNEL32.54)
 588  */
 589 DWORD WINAPI K32WOWCallback16( DWORD vpfn16, DWORD dwParam )
 590 {
 591     DWORD ret;
 592
 593     if ( !K32WOWCallback16Ex( vpfn16, WCB16_PASCAL,
 594                            sizeof(DWORD), &dwParam, &ret ) )
 595         ret = 0L;
 596
 597     return ret;
 598 }
 599
 600
 601 /*
 602  *  16-bit WOW routines (in KERNEL)
 603  */
 604
 605 /**********************************************************************
 606  *           GetVDMPointer32W      (KERNEL.516)
 607  */
 608 DWORD WINAPI GetVDMPointer32W16( SEGPTR vp, UINT16 fMode )
 609 {
 610     GlobalPageLock16(GlobalHandle16(SELECTOROF(vp)));
 611     return (DWORD)K32WOWGetVDMPointer( vp, 0, (DWORD)fMode );
 612 }
 613
 614 /***********************************************************************
 615  *           LoadLibraryEx32W      (KERNEL.513)
 616  */
 617 DWORD WINAPI LoadLibraryEx32W16( LPCSTR lpszLibFile, DWORD hFile, DWORD dwFlags )
 618 {
 619     HMODULE hModule;
 620     DOS_FULL_NAME full_name;
 621     DWORD mutex_count;
 622     UNICODE_STRING libfileW;
 623     LPCWSTR filenameW;
 624     static const WCHAR dllW[] = {'.','D','L','L',0};
 625
 626     if (!lpszLibFile)
 627     {
 628         SetLastError(ERROR_INVALID_PARAMETER);
 629         return 0;
 630     }
 631
 632     if (!RtlCreateUnicodeStringFromAsciiz(&libfileW, lpszLibFile))
 633     {
 634         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 635         return 0;
 636     }
 637
 638     /* if the file can not be found, call LoadLibraryExA anyway, since it might be
 639        a buildin module. This case is handled in MODULE_LoadLibraryExA */
 640
 641     filenameW = libfileW.Buffer;
 642     if ( DIR_SearchPath( NULL, filenameW, dllW, &full_name, FALSE ) )
 643         filenameW = full_name.short_name;
 644
 645     ReleaseThunkLock( &mutex_count );
 646     hModule = LoadLibraryExW( filenameW, (HANDLE)hFile, dwFlags );
 647     RestoreThunkLock( mutex_count );
 648
 649     RtlFreeUnicodeString(&libfileW);
 650
 651     return (DWORD)hModule;
 652 }
 653
 654 /***********************************************************************
 655  *           GetProcAddress32W     (KERNEL.515)
 656  */
 657 DWORD WINAPI GetProcAddress32W16( DWORD hModule, LPCSTR lpszProc )
 658 {
 659     return (DWORD)GetProcAddress( (HMODULE)hModule, lpszProc );
 660 }
 661
 662 /***********************************************************************
 663  *           FreeLibrary32W        (KERNEL.514)
 664  */
 665 DWORD WINAPI FreeLibrary32W16( DWORD hLibModule )
 666 {
 667     BOOL retv;
 668     DWORD mutex_count;
 669
 670     ReleaseThunkLock( &mutex_count );
 671     retv = FreeLibrary( (HMODULE)hLibModule );
 672     RestoreThunkLock( mutex_count );
 673     return (DWORD)retv;
 674 }
 675
 676
 677 /**********************************************************************
 678  *           WOW_CallProc32W
 679  */
 680 static DWORD WOW_CallProc32W16( FARPROC proc32, DWORD nrofargs, DWORD *args )
 681 {
 682     DWORD ret;
 683     DWORD mutex_count;
 684
 685     ReleaseThunkLock( &mutex_count );
 686
 687     /*
 688      * FIXME:  If ( nrofargs & CPEX_DEST_CDECL ) != 0, we should call a
 689      *         32-bit CDECL routine ...
 690      */
 691
 692     if (!proc32) ret = 0;
 693     else switch (nrofargs)
 694     {
 695     case 0: ret = proc32();
 696             break;
 697     case 1: ret = proc32(args[0]);
 698             break;
 699     case 2: ret = proc32(args[0],args[1]);
 700             break;
 701     case 3: ret = proc32(args[0],args[1],args[2]);
 702             break;
 703     case 4: ret = proc32(args[0],args[1],args[2],args[3]);
 704             break;
 705     case 5: ret = proc32(args[0],args[1],args[2],args[3],args[4]);
 706             break;
 707     case 6: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5]);
 708             break;
 709     case 7: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
 710             break;
 711     case 8: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
 712             break;
 713     case 9: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
 714             break;
 715     case 10:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
 716             break;
 717     case 11:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
 718             break;
 719     case 12:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
 720             break;
 721     case 13:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
 722             break;
 723     case 14:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
 724             break;
 725     case 15:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
 726             break;
 727     default:
 728             /* FIXME: should go up to 32  arguments */
 729             ERR("Unsupported number of arguments %ld, please report.\n",nrofargs);
 730             ret = 0;
 731             break;
 732     }
 733
 734     RestoreThunkLock( mutex_count );
 735
 736     TRACE("returns %08lx\n",ret);
 737     return ret;
 738 }
 739
 740 /**********************************************************************
 741  *           CallProc32W           (KERNEL.517)
 742  */
 743 DWORD WINAPIV CallProc32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32, VA_LIST16 valist )
 744 {
 745     DWORD args[32];
 746     unsigned int i;
 747
 748     TRACE("(%ld,%ld,%p args[",nrofargs,argconvmask,proc32);
 749
 750     for (i=0;i<nrofargs;i++)
 751     {
 752         if (argconvmask & (1<<i))
 753         {
 754             SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 755             /* pascal convention, have to reverse the arguments order */
 756             args[nrofargs - i - 1] = (DWORD)MapSL(ptr);
 757             TRACE("%08lx(%p),",ptr,MapSL(ptr));
 758         }
 759         else
 760         {
 761             DWORD arg = VA_ARG16( valist, DWORD );
 762             /* pascal convention, have to reverse the arguments order */
 763             args[nrofargs - i - 1] = arg;
 764             TRACE("%ld,", arg);
 765         }
 766     }
 767     TRACE("])\n");
 768
 769     /* POP nrofargs DWORD arguments and 3 DWORD parameters */
 770     stack16_pop( (3 + nrofargs) * sizeof(DWORD) );
 771
 772     return WOW_CallProc32W16( proc32, nrofargs, args );
 773 }
 774
 775 /**********************************************************************
 776  *           _CallProcEx32W         (KERNEL.518)
 777  */
 778 DWORD WINAPIV CallProcEx32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32, VA_LIST16 valist )
 779 {
 780     DWORD args[32];
 781     unsigned int i;
 782
 783     TRACE("(%ld,%ld,%p args[",nrofargs,argconvmask,proc32);
 784
 785     for (i=0;i<nrofargs;i++)
 786     {
 787         if (argconvmask & (1<<i))
 788         {
 789             SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 790             args[i] = (DWORD)MapSL(ptr);
 791             TRACE("%08lx(%p),",ptr,MapSL(ptr));
 792         }
 793         else
 794         {
 795             DWORD arg = VA_ARG16( valist, DWORD );
 796             args[i] = arg;
 797             TRACE("%ld,", arg);
 798         }
 799     }
 800     TRACE("])\n");
 801     return WOW_CallProc32W16( proc32, nrofargs, args );
 802 }
 803
 804
 805 /**********************************************************************
 806  *           WOW16Call               (KERNEL.500)
 807  *
 808  * FIXME!!!
 809  *
 810  */
 811 DWORD WINAPIV WOW16Call(WORD x, WORD y, WORD z, VA_LIST16 args)
 812 {
 813         int     i;
 814         DWORD   calladdr;
 815         FIXME("(0x%04x,0x%04x,%d),calling (",x,y,z);
 816
 817         for (i=0;i<x/2;i++) {
 818                 WORD    a = VA_ARG16(args,WORD);
 819                 DPRINTF("%04x ",a);
 820         }
 821         calladdr = VA_ARG16(args,DWORD);
 822         stack16_pop( 3*sizeof(WORD) + x + sizeof(DWORD) );
 823         DPRINTF(") calling address was 0x%08lx\n",calladdr);
 824         return 0;
 825 }
 826
 827
 828 /***********************************************************************
 829  *           CreateThread16   (KERNEL.441)
 830  */
 831 HANDLE WINAPI CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
 832                               FARPROC16 start, SEGPTR param,
 833                               DWORD flags, LPDWORD id )
 834 {
 835     struct thread_args *args = HeapAlloc( GetProcessHeap(), 0, sizeof(*args) );
 836     if (!args) return INVALID_HANDLE_VALUE;
 837     args->proc = start;
 838     args->param = param;
 839     return CreateThread( sa, stack, start_thread16, args, flags, id );
 840 }