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