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